Class LZ4


  • final class LZ4
    extends java.lang.Object
    LZ4 compression and decompression routines. http://code.google.com/p/lz4/ http://fastcompression.blogspot.fr/p/lz4.html
    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      (package private) static class  LZ4.HashTable  
      (package private) static class  LZ4.HCHashTable  
      private static class  LZ4.Match  
    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private LZ4()  
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      private static int commonBytes​(byte[] b, int o1, int o2, int limit)  
      private static int commonBytesBackward​(byte[] b, int o1, int o2, int l1, int l2)  
      static void compress​(byte[] bytes, int off, int len, DataOutput out, LZ4.HashTable ht)
      Compress bytes[off:off+len] into out using at most 16KB of memory.
      static void compressHC​(byte[] src, int srcOff, int srcLen, DataOutput out, LZ4.HCHashTable ht)
      Compress bytes[off:off+len] into out.
      private static void copyTo​(LZ4.Match m1, LZ4.Match m2)  
      static int decompress​(DataInput compressed, int decompressedLen, byte[] dest, int dOff)
      Decompress at least decompressedLen bytes into dest[dOff:].
      private static void encodeLastLiterals​(byte[] bytes, int anchor, int literalLen, DataOutput out)  
      private static void encodeLen​(int l, DataOutput out)  
      private static void encodeLiterals​(byte[] bytes, int token, int anchor, int literalLen, DataOutput out)  
      private static void encodeSequence​(byte[] bytes, int anchor, int matchRef, int matchOff, int matchLen, DataOutput out)  
      private static int hash​(int i, int hashBits)  
      private static int hashHC​(int i)  
      private static int readInt​(byte[] buf, int i)  
      private static boolean readIntEquals​(byte[] buf, int i, int j)  
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • LZ4

        private LZ4()
    • Method Detail

      • hash

        private static int hash​(int i,
                                int hashBits)
      • hashHC

        private static int hashHC​(int i)
      • readInt

        private static int readInt​(byte[] buf,
                                   int i)
      • readIntEquals

        private static boolean readIntEquals​(byte[] buf,
                                             int i,
                                             int j)
      • commonBytes

        private static int commonBytes​(byte[] b,
                                       int o1,
                                       int o2,
                                       int limit)
      • commonBytesBackward

        private static int commonBytesBackward​(byte[] b,
                                               int o1,
                                               int o2,
                                               int l1,
                                               int l2)
      • decompress

        public static int decompress​(DataInput compressed,
                                     int decompressedLen,
                                     byte[] dest,
                                     int dOff)
                              throws java.io.IOException
        Decompress at least decompressedLen bytes into dest[dOff:]. Please note that dest must be large enough to be able to hold all decompressed data (meaning that you need to know the total decompressed length).
        Throws:
        java.io.IOException
      • encodeLen

        private static void encodeLen​(int l,
                                      DataOutput out)
                               throws java.io.IOException
        Throws:
        java.io.IOException
      • encodeLiterals

        private static void encodeLiterals​(byte[] bytes,
                                           int token,
                                           int anchor,
                                           int literalLen,
                                           DataOutput out)
                                    throws java.io.IOException
        Throws:
        java.io.IOException
      • encodeLastLiterals

        private static void encodeLastLiterals​(byte[] bytes,
                                               int anchor,
                                               int literalLen,
                                               DataOutput out)
                                        throws java.io.IOException
        Throws:
        java.io.IOException
      • encodeSequence

        private static void encodeSequence​(byte[] bytes,
                                           int anchor,
                                           int matchRef,
                                           int matchOff,
                                           int matchLen,
                                           DataOutput out)
                                    throws java.io.IOException
        Throws:
        java.io.IOException
      • compress

        public static void compress​(byte[] bytes,
                                    int off,
                                    int len,
                                    DataOutput out,
                                    LZ4.HashTable ht)
                             throws java.io.IOException
        Compress bytes[off:off+len] into out using at most 16KB of memory. ht shouldn't be shared across threads but can safely be reused.
        Throws:
        java.io.IOException
      • compressHC

        public static void compressHC​(byte[] src,
                                      int srcOff,
                                      int srcLen,
                                      DataOutput out,
                                      LZ4.HCHashTable ht)
                               throws java.io.IOException
        Compress bytes[off:off+len] into out. Compared to compress(byte[], int, int, DataOutput, HashTable), this method is slower and uses more memory (~ 256KB per thread) but should provide better compression ratios (especially on large inputs) because it chooses the best match among up to 256 candidates and then performs trade-offs to fix overlapping matches. ht shouldn't be shared across threads but can safely be reused.
        Throws:
        java.io.IOException