func ExampleWriter_RegisterCompressor() {
// Override the default Deflate compressor with a higher compression
// level.
// Create a buffer to write our archive to.
buf := new(bytes.Buffer)
// Create a new zip archive.
w := zip.NewWriter(buf)
var fw *flate.Writer
// Register the deflator.
w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
var err error
if fw == nil {
// Creating a flate compressor for every file is
// expensive, create one and reuse it.
fw, err = flate.NewWriter(out, flate.BestCompression)
} else {
fw.Reset(out)
}
return fw, err
})
// Proceed to add files to w.
}
func Zip(unBytes []byte, contentEncoding string) (zipBytes []byte, err error) {
switch contentEncoding {
case "":
zipBytes = unBytes
break
case "gzip":
var bf bytes.Buffer
gw := gzip.NewWriter(&bf)
gw.Write(unBytes)
gw.Close()
zipBytes = bf.Bytes()
case "deflate":
var bf bytes.Buffer
var gw *flate.Writer
gw, err = flate.NewWriter(&bf, -1)
if err != nil {
return
}
gw.Write(unBytes)
gw.Close()
zipBytes = bf.Bytes()
default:
err = fmt.Errorf("Zip Unkown Content-Encoding: %v", contentEncoding)
}
return
}
func main() {
var file *os.File
var err error
var writer *flate.Writer
var body []byte
if file, err = os.Create("output/sample.tar.flate"); err != nil {
log.Fatalln(err)
}
defer file.Close()
// flateはレベルを指定する。flate.BestSpeed or flate.BestCompression or DefaultCompression
if writer, err = flate.NewWriter(file, flate.BestCompression); err != nil {
log.Fatalln(err)
}
defer writer.Close()
var filepaths = []string{
"files/b0044482_1413812.jpg",
"files/dart_flight_school.png",
"files/golang.txt",
}
// buf := new(bytes.Buffer)
// tw := tar.NewWriter(buf)
tw := tar.NewWriter(writer)
defer tw.Close()
for _, filepath := range filepaths {
if body, err = ioutil.ReadFile(filepath); err != nil {
log.Fatalln(err)
}
if body != nil {
hdr := &tar.Header{
Name: path.Base(filepath),
Size: int64(len(body)),
}
if err := tw.WriteHeader(hdr); err != nil {
println(err)
}
if _, err := tw.Write(body); err != nil {
println(err)
}
}
}
// writer.Write(buf.Bytes())
// writer.Flush()
}
func (self *FlateCompressor) Compress(src []byte) ([]byte, error) {
var err error
var compressor *flate.Writer
cdest := bytes.NewBuffer(make([]byte, 0, len(src)))
if self.dict == nil {
compressor, err = flate.NewWriter(cdest, self.level)
} else {
compressor, err = flate.NewWriterDict(cdest, self.level, self.dict)
}
//compressor.Reset(cdest)
compressor.Write(src)
err = compressor.Close()
if err != nil {
fmt.Println("Compress Close err:%s", err.Error())
}
return cdest.Bytes(), err
}
func (e *Engine) deflate() error {
var buf bytes.Buffer
var level int
var err error
level, err = e.stack.PopInt()
if err == nil {
var w *flate.Writer
w, err = flate.NewWriter(&buf, level)
if err == nil {
_, err = w.Write(e.stack.Pop())
w.Close()
}
}
if err == nil {
e.stack.Push(buf.Bytes())
}
return err
}
func readFile(filePath string) (string, error) {
var buf []byte
var err error
var n int
var writer *flate.Writer
var encoder io.WriteCloser
var file *os.File
var data *bytes.Buffer = new(bytes.Buffer)
if file, err = os.Open(filePath); err != nil {
return "", err
}
defer file.Close()
encoder = ascii85.NewEncoder(data)
defer encoder.Close()
writer, err = flate.NewWriter(encoder, flate.BestCompression)
defer writer.Close()
buf = make([]byte, 8192)
err = nil
for {
if n, err = file.Read(buf); err != nil {
if err == io.EOF {
break
} else {
return "", err
}
}
if n == 8192 {
_, err = writer.Write(buf)
} else {
_, err = writer.Write(buf[:n])
}
if err != nil {
return "", err
}
}
if err = writer.Flush(); err != nil {
return "", err
}
return strconv.Quote(string(data.Bytes())), nil
}
// ReturnWriter returns a flate.Writer to the pool that can
// late be reused via GetWriter.
// Don't close the writer, Flush will be called before returning
// it to the pool.
func (pool *DeflatePool) ReturnWriter(writer *flate.Writer) {
writer.Close()
pool.pool.Put(writer)
}
func releaseFlateWriter(r *flate.Writer) {
r.Reset(emptyBuffer) // release the previous io.Writer
flateWriterPool.Put(r)
}