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