GzipCodec.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:6k
源码类别:

网格计算

开发平台:

Java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.io.compress;
  19. import java.io.*;
  20. import java.util.zip.GZIPOutputStream;
  21. import java.util.zip.GZIPInputStream;
  22. import org.apache.hadoop.io.compress.DefaultCodec;
  23. import org.apache.hadoop.io.compress.zlib.*;
  24. /**
  25.  * This class creates gzip compressors/decompressors. 
  26.  */
  27. public class GzipCodec extends DefaultCodec {
  28.   /**
  29.    * A bridge that wraps around a DeflaterOutputStream to make it 
  30.    * a CompressionOutputStream.
  31.    */
  32.   protected static class GzipOutputStream extends CompressorStream {
  33.     private static class ResetableGZIPOutputStream extends GZIPOutputStream {
  34.       
  35.       public ResetableGZIPOutputStream(OutputStream out) throws IOException {
  36.         super(out);
  37.       }
  38.       
  39.       public void resetState() throws IOException {
  40.         def.reset();
  41.       }
  42.     }
  43.     public GzipOutputStream(OutputStream out) throws IOException {
  44.       super(new ResetableGZIPOutputStream(out));
  45.     }
  46.     
  47.     /**
  48.      * Allow children types to put a different type in here.
  49.      * @param out the Deflater stream to use
  50.      */
  51.     protected GzipOutputStream(CompressorStream out) {
  52.       super(out);
  53.     }
  54.     
  55.     public void close() throws IOException {
  56.       out.close();
  57.     }
  58.     
  59.     public void flush() throws IOException {
  60.       out.flush();
  61.     }
  62.     
  63.     public void write(int b) throws IOException {
  64.       out.write(b);
  65.     }
  66.     
  67.     public void write(byte[] data, int offset, int length) 
  68.       throws IOException {
  69.       out.write(data, offset, length);
  70.     }
  71.     
  72.     public void finish() throws IOException {
  73.       ((ResetableGZIPOutputStream) out).finish();
  74.     }
  75.     public void resetState() throws IOException {
  76.       ((ResetableGZIPOutputStream) out).resetState();
  77.     }
  78.   }
  79.   
  80.   protected static class GzipInputStream extends DecompressorStream {
  81.     
  82.     private static class ResetableGZIPInputStream extends GZIPInputStream {
  83.       public ResetableGZIPInputStream(InputStream in) throws IOException {
  84.         super(in);
  85.       }
  86.       
  87.       public void resetState() throws IOException {
  88.         inf.reset();
  89.       }
  90.     }
  91.     
  92.     public GzipInputStream(InputStream in) throws IOException {
  93.       super(new ResetableGZIPInputStream(in));
  94.     }
  95.     
  96.     /**
  97.      * Allow subclasses to directly set the inflater stream.
  98.      */
  99.     protected GzipInputStream(DecompressorStream in) {
  100.       super(in);
  101.     }
  102.     public int available() throws IOException {
  103.       return in.available(); 
  104.     }
  105.     public void close() throws IOException {
  106.       in.close();
  107.     }
  108.     public int read() throws IOException {
  109.       return in.read();
  110.     }
  111.     
  112.     public int read(byte[] data, int offset, int len) throws IOException {
  113.       return in.read(data, offset, len);
  114.     }
  115.     
  116.     public long skip(long offset) throws IOException {
  117.       return in.skip(offset);
  118.     }
  119.     
  120.     public void resetState() throws IOException {
  121.       ((ResetableGZIPInputStream) in).resetState();
  122.     }
  123.   }  
  124.   
  125.   public CompressionOutputStream createOutputStream(OutputStream out) 
  126.     throws IOException {
  127.     return (ZlibFactory.isNativeZlibLoaded(conf)) ?
  128.                new CompressorStream(out, createCompressor(),
  129.                                     conf.getInt("io.file.buffer.size", 4*1024)) :
  130.                new GzipOutputStream(out);
  131.   }
  132.   
  133.   public CompressionOutputStream createOutputStream(OutputStream out, 
  134.                                                     Compressor compressor) 
  135.   throws IOException {
  136.     return (compressor != null) ?
  137.                new CompressorStream(out, compressor,
  138.                                     conf.getInt("io.file.buffer.size", 
  139.                                                 4*1024)) :
  140.                createOutputStream(out);                                               
  141.   }
  142.   public Compressor createCompressor() {
  143.     return (ZlibFactory.isNativeZlibLoaded(conf))
  144.       ? new GzipZlibCompressor()
  145.       : null;
  146.   }
  147.   public Class<? extends Compressor> getCompressorType() {
  148.     return ZlibFactory.isNativeZlibLoaded(conf)
  149.       ? GzipZlibCompressor.class
  150.       : BuiltInZlibDeflater.class;
  151.   }
  152.   public CompressionInputStream createInputStream(InputStream in) 
  153.   throws IOException {
  154.   return (ZlibFactory.isNativeZlibLoaded(conf)) ?
  155.              new DecompressorStream(in, createDecompressor(),
  156.                                     conf.getInt("io.file.buffer.size", 
  157.                                                 4*1024)) :
  158.              new GzipInputStream(in);                                         
  159.   }
  160.   public CompressionInputStream createInputStream(InputStream in, 
  161.                                                   Decompressor decompressor) 
  162.   throws IOException {
  163.     return (decompressor != null) ? 
  164.                new DecompressorStream(in, decompressor,
  165.                                       conf.getInt("io.file.buffer.size", 
  166.                                                   4*1024)) :
  167.                createInputStream(in); 
  168.   }
  169.   public Decompressor createDecompressor() {
  170.     return (ZlibFactory.isNativeZlibLoaded(conf))
  171.       ? new GzipZlibDecompressor()
  172.       : null;
  173.   }
  174.   public Class<? extends Decompressor> getDecompressorType() {
  175.     return ZlibFactory.isNativeZlibLoaded(conf)
  176.       ? GzipZlibDecompressor.class
  177.       : BuiltInZlibInflater.class;
  178.   }
  179.   public String getDefaultExtension() {
  180.     return ".gz";
  181.   }
  182.   static final class GzipZlibCompressor extends ZlibCompressor {
  183.     public GzipZlibCompressor() {
  184.       super(ZlibCompressor.CompressionLevel.DEFAULT_COMPRESSION,
  185.           ZlibCompressor.CompressionStrategy.DEFAULT_STRATEGY,
  186.           ZlibCompressor.CompressionHeader.GZIP_FORMAT, 64*1024);
  187.     }
  188.   }
  189.   static final class GzipZlibDecompressor extends ZlibDecompressor {
  190.     public GzipZlibDecompressor() {
  191.       super(ZlibDecompressor.CompressionHeader.AUTODETECT_GZIP_ZLIB, 64*1024);
  192.     }
  193.   }
  194. }