- * This class compresses data into fixed-size blocks of compressed data. - * @see LZ4BlockInputStream - */ -public final class LZ4BlockOutputStream extends FilterOutputStream { - - static final byte[] MAGIC = new byte[] { 'L', 'Z', '4', 'B', 'l', 'o', 'c', 'k' }; - static final int MAGIC_LENGTH = MAGIC.length; - - static final int HEADER_LENGTH = - MAGIC_LENGTH // magic bytes - + 1 // token - + 4 // compressed length - + 4 // decompressed length - + 4; // checksum - - static final int COMPRESSION_LEVEL_BASE = 10; - static final int MIN_BLOCK_SIZE = 64; - static final int MAX_BLOCK_SIZE = 1 << (COMPRESSION_LEVEL_BASE + 0x0F); - - static final int COMPRESSION_METHOD_RAW = 0x10; - static final int COMPRESSION_METHOD_LZ4 = 0x20; - - static final int DEFAULT_SEED = 0x9747b28c; - - private static int compressionLevel(int blockSize) { - if (blockSize < MIN_BLOCK_SIZE) { - throw new IllegalArgumentException("blockSize must be >= " + MIN_BLOCK_SIZE + ", got " + blockSize); - } else if (blockSize > MAX_BLOCK_SIZE) { - throw new IllegalArgumentException("blockSize must be <= " + MAX_BLOCK_SIZE + ", got " + blockSize); - } - int compressionLevel = 32 - Integer.numberOfLeadingZeros(blockSize - 1); // ceil of log2 - assert (1 << compressionLevel) >= blockSize; - assert blockSize * 2 > (1 << compressionLevel); - compressionLevel = Math.max(0, compressionLevel - COMPRESSION_LEVEL_BASE); - assert compressionLevel >= 0 && compressionLevel <= 0x0F; - return compressionLevel; - } - - private final int blockSize; - private final int compressionLevel; - private final LZ4Compressor compressor; - private final Checksum checksum; - private final byte[] buffer; - private final byte[] compressedBuffer; - private final boolean syncFlush; - private boolean finished; - private int o; - - /** - * Create a new {@link OutputStream} with configurable block size. Large - * blocks require more memory at compression and decompression time but - * should improve the compression ratio. - * - * @param out the {@link OutputStream} to feed - * @param blockSize the maximum number of bytes to try to compress at once, - * must be >= 64 and <= 32 M - * @param compressor the {@link LZ4Compressor} instance to use to compress - * data - * @param checksum the {@link Checksum} instance to use to check data for - * integrity. - * @param syncFlush true if pending data should also be flushed on {@link #flush()} - */ - public LZ4BlockOutputStream(OutputStream out, int blockSize, LZ4Compressor compressor, Checksum checksum, boolean syncFlush) { - super(out); - this.blockSize = blockSize; - this.compressor = compressor; - this.checksum = checksum; - this.compressionLevel = compressionLevel(blockSize); - this.buffer = new byte[blockSize]; - final int compressedBlockSize = HEADER_LENGTH + compressor.maxCompressedLength(blockSize); - this.compressedBuffer = new byte[compressedBlockSize]; - this.syncFlush = syncFlush; - o = 0; - finished = false; - System.arraycopy(MAGIC, 0, compressedBuffer, 0, MAGIC_LENGTH); - } - - /** - * Create a new instance which checks stream integrity using - * {@link StreamingXXHash32} and doesn't sync flush. - * @see #LZ4BlockOutputStream(OutputStream, int, LZ4Compressor, Checksum, boolean) - * @see StreamingXXHash32#asChecksum() - */ - public LZ4BlockOutputStream(OutputStream out, int blockSize, LZ4Compressor compressor) { - this(out, blockSize, compressor, XXHashFactory.fastestInstance().newStreamingHash32(DEFAULT_SEED).asChecksum(), false); - } - - /** - * Create a new instance which compresses with the standard LZ4 compression - * algorithm. - * @see #LZ4BlockOutputStream(OutputStream, int, LZ4Compressor) - * @see LZ4Factory#fastCompressor() - */ - public LZ4BlockOutputStream(OutputStream out, int blockSize) { - this(out, blockSize, LZ4Factory.fastestInstance().fastCompressor()); - } - - /** - * Create a new instance which compresses into blocks of 64 KB. - * @see #LZ4BlockOutputStream(OutputStream, int) - */ - public LZ4BlockOutputStream(OutputStream out) { - this(out, 1 << 16); - } - - private void ensureNotFinished() { - if (finished) { - throw new IllegalStateException("This stream is already closed"); - } - } - - @Override - public void write(int b) throws IOException { - ensureNotFinished(); - if (o == blockSize) { - flushBufferedData(); - } - buffer[o++] = (byte) b; - } - - @Override - public void write(byte[] b, int off, int len) throws IOException { - SafeUtils.checkRange(b, off, len); - ensureNotFinished(); - - while (o + len > blockSize) { - final int l = blockSize - o; - System.arraycopy(b, off, buffer, o, blockSize - o); - o = blockSize; - flushBufferedData(); - off += l; - len -= l; - } - System.arraycopy(b, off, buffer, o, len); - o += len; - } - - @Override - public void write(byte[] b) throws IOException { - ensureNotFinished(); - write(b, 0, b.length); - } - - @Override - public void close() throws IOException { - if (!finished) { - finish(); - } - if (out != null) { - out.close(); - out = null; - } - } - - private void flushBufferedData() throws IOException { - if (o == 0) { - return; - } - checksum.reset(); - checksum.update(buffer, 0, o); - final int check = (int) checksum.getValue(); - int compressedLength = compressor.compress(buffer, 0, o, compressedBuffer, HEADER_LENGTH); - final int compressMethod; - if (compressedLength >= o) { - compressMethod = COMPRESSION_METHOD_RAW; - compressedLength = o; - System.arraycopy(buffer, 0, compressedBuffer, HEADER_LENGTH, o); - } else { - compressMethod = COMPRESSION_METHOD_LZ4; - } - - compressedBuffer[MAGIC_LENGTH] = (byte) (compressMethod | compressionLevel); - writeIntLE(compressedLength, compressedBuffer, MAGIC_LENGTH + 1); - writeIntLE(o, compressedBuffer, MAGIC_LENGTH + 5); - writeIntLE(check, compressedBuffer, MAGIC_LENGTH + 9); - assert MAGIC_LENGTH + 13 == HEADER_LENGTH; - out.write(compressedBuffer, 0, HEADER_LENGTH + compressedLength); - o = 0; - } - - /** - * Flush this compressed {@link OutputStream}. - * - * If the stream has been created with syncFlush=true, pending - * data will be compressed and appended to the underlying {@link OutputStream} - * before calling {@link OutputStream#flush()} on the underlying stream. - * Otherwise, this method just flushes the underlying stream, so pending - * data might not be available for reading until {@link #finish()} or - * {@link #close()} is called. - */ - @Override - public void flush() throws IOException { - if (out != null) { - if (syncFlush) { - flushBufferedData(); - } - out.flush(); - } - } - - /** - * Same as {@link #close()} except that it doesn't close the underlying stream. - * This can be useful if you want to keep on using the underlying stream. - */ - public void finish() throws IOException { - ensureNotFinished(); - flushBufferedData(); - compressedBuffer[MAGIC_LENGTH] = (byte) (COMPRESSION_METHOD_RAW | compressionLevel); - writeIntLE(0, compressedBuffer, MAGIC_LENGTH + 1); - writeIntLE(0, compressedBuffer, MAGIC_LENGTH + 5); - writeIntLE(0, compressedBuffer, MAGIC_LENGTH + 9); - assert MAGIC_LENGTH + 13 == HEADER_LENGTH; - out.write(compressedBuffer, 0, HEADER_LENGTH); - finished = true; - out.flush(); - } - - private static void writeIntLE(int i, byte[] buf, int off) { - buf[off++] = (byte) i; - buf[off++] = (byte) (i >>> 8); - buf[off++] = (byte) (i >>> 16); - buf[off++] = (byte) (i >>> 24); - } - - @Override - public String toString() { - return getClass().getSimpleName() + "(out=" + out + ", blockSize=" + blockSize - + ", compressor=" + compressor + ", checksum=" + checksum + ")"; - } - -} diff --git a/core/src/main/java/net/jpountz/lz4/LZ4ByteBufferUtils.java b/core/src/main/java/net/jpountz/lz4/LZ4ByteBufferUtils.java index 3c0b9ac6..44e707ff 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4ByteBufferUtils.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4ByteBufferUtils.java @@ -14,6 +14,10 @@ package net.jpountz.lz4; * limitations under the License. */ +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + + import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH; import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; import static net.jpountz.lz4.LZ4Constants.ML_BITS; @@ -26,9 +30,6 @@ import static net.jpountz.util.ByteBufferUtils.writeByte; import static net.jpountz.util.ByteBufferUtils.writeInt; import static net.jpountz.util.ByteBufferUtils.writeLong; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; - enum LZ4ByteBufferUtils { ; static int hash(ByteBuffer buf, int i) { diff --git a/core/src/main/java/net/jpountz/lz4/LZ4Factory.java b/core/src/main/java/net/jpountz/lz4/LZ4Factory.java index 7d1cf271..6f88a707 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4Factory.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4Factory.java @@ -18,9 +18,10 @@ import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.util.Arrays; - import net.jpountz.util.Native; import net.jpountz.util.Utils; + + import static net.jpountz.lz4.LZ4Constants.DEFAULT_COMPRESSION_LEVEL; import static net.jpountz.lz4.LZ4Constants.MAX_COMPRESSION_LEVEL; @@ -244,12 +245,6 @@ public final class LZ4Factory { return fastDecompressor(); } - /** Prints the fastest instance. */ - public static void main(String[] args) { - System.out.println("Fastest instance is " + fastestInstance()); - System.out.println("Fastest Java instance is " + fastestJavaInstance()); - } - @Override public String toString() { return getClass().getSimpleName() + ":" + impl; diff --git a/core/src/main/java/net/jpountz/lz4/LZ4HCJNICompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4HCJNICompressor.java index da721e31..aa2d1fe0 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4HCJNICompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4HCJNICompressor.java @@ -14,13 +14,13 @@ package net.jpountz.lz4; * limitations under the License. */ -import static net.jpountz.lz4.LZ4Constants.DEFAULT_COMPRESSION_LEVEL; - import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; + +import static net.jpountz.lz4.LZ4Constants.DEFAULT_COMPRESSION_LEVEL; + /** * High compression {@link LZ4Compressor}s implemented with JNI bindings to the * original C implementation of LZ4. diff --git a/core/src/main/java/net/jpountz/lz4/LZ4HCJavaSafeCompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4HCJavaSafeCompressor.java index f4ec3bd8..155497df 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4HCJavaSafeCompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4HCJavaSafeCompressor.java @@ -2,16 +2,24 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; -import static net.jpountz.lz4.LZ4Utils.*; - import java.nio.ByteBuffer; import java.util.Arrays; - import net.jpountz.lz4.LZ4Utils.Match; import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; + +import static net.jpountz.lz4.LZ4Constants.DEFAULT_COMPRESSION_LEVEL; +import static net.jpountz.lz4.LZ4Constants.HASH_TABLE_SIZE_HC; +import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; +import static net.jpountz.lz4.LZ4Constants.MAX_DISTANCE; +import static net.jpountz.lz4.LZ4Constants.MF_LIMIT; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.OPTIMAL_ML; +import static net.jpountz.lz4.LZ4Utils.copyTo; +import static net.jpountz.lz4.LZ4Utils.hashHC; + /** * High compression compressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4HCJavaUnsafeCompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4HCJavaUnsafeCompressor.java index 0f503221..71552c84 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4HCJavaUnsafeCompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4HCJavaUnsafeCompressor.java @@ -2,549 +2,559 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; -import static net.jpountz.lz4.LZ4Utils.*; - import java.nio.ByteBuffer; import java.util.Arrays; - import net.jpountz.lz4.LZ4Utils.Match; import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.UnsafeUtils; + +import static net.jpountz.lz4.LZ4Constants.DEFAULT_COMPRESSION_LEVEL; +import static net.jpountz.lz4.LZ4Constants.HASH_TABLE_SIZE_HC; +import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; +import static net.jpountz.lz4.LZ4Constants.MAX_DISTANCE; +import static net.jpountz.lz4.LZ4Constants.MF_LIMIT; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.OPTIMAL_ML; +import static net.jpountz.lz4.LZ4Utils.copyTo; +import static net.jpountz.lz4.LZ4Utils.hashHC; + /** * High compression compressor. */ final class LZ4HCJavaUnsafeCompressor extends LZ4Compressor { - public static final LZ4Compressor INSTANCE = new LZ4HCJavaUnsafeCompressor(); + public static final LZ4Compressor INSTANCE = new LZ4HCJavaUnsafeCompressor(); - private final int maxAttempts; - final int compressionLevel; - - LZ4HCJavaUnsafeCompressor() { this(DEFAULT_COMPRESSION_LEVEL); } - LZ4HCJavaUnsafeCompressor(int compressionLevel) { - this.maxAttempts = 1<<(compressionLevel-1); - this.compressionLevel = compressionLevel; - } + private final int maxAttempts; + final int compressionLevel; - private class HashTable { - static final int MASK = MAX_DISTANCE - 1; - int nextToUpdate; - private final int base; - private final int[] hashTable; - private final short[] chainTable; - - HashTable(int base) { - this.base = base; - nextToUpdate = base; - hashTable = new int[HASH_TABLE_SIZE_HC]; - Arrays.fill(hashTable, -1); - chainTable = new short[MAX_DISTANCE]; + LZ4HCJavaUnsafeCompressor() { + this(DEFAULT_COMPRESSION_LEVEL); } - private int hashPointer(byte[] bytes, int off) { - final int v = UnsafeUtils.readInt(bytes, off); - return hashPointer(v); + LZ4HCJavaUnsafeCompressor(int compressionLevel) { + this.maxAttempts = 1 << (compressionLevel - 1); + this.compressionLevel = compressionLevel; } - private int hashPointer(ByteBuffer bytes, int off) { - final int v = ByteBufferUtils.readInt(bytes, off); - return hashPointer(v); - } + private class HashTable { + static final int MASK = MAX_DISTANCE - 1; + int nextToUpdate; + private final int base; + private final int[] hashTable; + private final short[] chainTable; - private int hashPointer(int v) { - final int h = hashHC(v); - return hashTable[h]; - } - - private int next(int off) { - return off - (chainTable[off & MASK] & 0xFFFF); - } - - private void addHash(byte[] bytes, int off) { - final int v = UnsafeUtils.readInt(bytes, off); - addHash(v, off); - } - - private void addHash(ByteBuffer bytes, int off) { - final int v = ByteBufferUtils.readInt(bytes, off); - addHash(v, off); - } - - private void addHash(int v, int off) { - final int h = hashHC(v); - int delta = off - hashTable[h]; - assert delta > 0 : delta; - if (delta >= MAX_DISTANCE) { - delta = MAX_DISTANCE - 1; - } - chainTable[off & MASK] = (short) delta; - hashTable[h] = off; - } - - void insert(int off, byte[] bytes) { - for (; nextToUpdate < off; ++nextToUpdate) { - addHash(bytes, nextToUpdate); - } - } - - void insert(int off, ByteBuffer bytes) { - for (; nextToUpdate < off; ++nextToUpdate) { - addHash(bytes, nextToUpdate); - } - } - - - - boolean insertAndFindBestMatch(byte[] buf, int off, int matchLimit, Match match) { - match.start = off; - match.len = 0; - int delta = 0; - int repl = 0; - - insert(off, buf); - - int ref = hashPointer(buf, off); - - if (ref >= off - 4 && ref <= off && ref >= base) { // potential repetition - if (LZ4UnsafeUtils.readIntEquals(buf, ref, off)) { // confirmed - delta = off - ref; - repl = match.len = MIN_MATCH + LZ4UnsafeUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); - match.ref = ref; - } - ref = next(ref); - } - - for (int i = 0; i < maxAttempts; ++i) { - if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { - break; - } - if (LZ4UnsafeUtils.readIntEquals(buf, ref, off)) { - final int matchLen = MIN_MATCH + LZ4UnsafeUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); - if (matchLen > match.len) { - match.ref = ref; - match.len = matchLen; - } - } - ref = next(ref); - } - - if (repl != 0) { - int ptr = off; - final int end = off + repl - (MIN_MATCH - 1); - while (ptr < end - delta) { - chainTable[ptr & MASK] = (short) delta; // pre load - ++ptr; - } - do { - chainTable[ptr & MASK] = (short) delta; - hashTable[hashHC(UnsafeUtils.readInt(buf, ptr))] = ptr; - ++ptr; - } while (ptr < end); - nextToUpdate = end; - } - - return match.len != 0; - } - - boolean insertAndFindWiderMatch(byte[] buf, int off, int startLimit, int matchLimit, int minLen, Match match) { - match.len = minLen; - - insert(off, buf); - - final int delta = off - startLimit; - int ref = hashPointer(buf, off); - for (int i = 0; i < maxAttempts; ++i) { - if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { - break; - } - if (LZ4UnsafeUtils.readIntEquals(buf, ref, off)) { - final int matchLenForward = MIN_MATCH +LZ4UnsafeUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); - final int matchLenBackward = LZ4UnsafeUtils.commonBytesBackward(buf, ref, off, base, startLimit); - final int matchLen = matchLenBackward + matchLenForward; - if (matchLen > match.len) { - match.len = matchLen; - match.ref = ref - matchLenBackward; - match.start = off - matchLenBackward; - } - } - ref = next(ref); - } - - return match.len > minLen; - } - - - boolean insertAndFindBestMatch(ByteBuffer buf, int off, int matchLimit, Match match) { - match.start = off; - match.len = 0; - int delta = 0; - int repl = 0; - - insert(off, buf); - - int ref = hashPointer(buf, off); - - if (ref >= off - 4 && ref <= off && ref >= base) { // potential repetition - if (LZ4ByteBufferUtils.readIntEquals(buf, ref, off)) { // confirmed - delta = off - ref; - repl = match.len = MIN_MATCH + LZ4ByteBufferUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); - match.ref = ref; - } - ref = next(ref); - } - - for (int i = 0; i < maxAttempts; ++i) { - if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { - break; - } - if (LZ4ByteBufferUtils.readIntEquals(buf, ref, off)) { - final int matchLen = MIN_MATCH + LZ4ByteBufferUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); - if (matchLen > match.len) { - match.ref = ref; - match.len = matchLen; - } - } - ref = next(ref); - } - - if (repl != 0) { - int ptr = off; - final int end = off + repl - (MIN_MATCH - 1); - while (ptr < end - delta) { - chainTable[ptr & MASK] = (short) delta; // pre load - ++ptr; - } - do { - chainTable[ptr & MASK] = (short) delta; - hashTable[hashHC(ByteBufferUtils.readInt(buf, ptr))] = ptr; - ++ptr; - } while (ptr < end); - nextToUpdate = end; - } - - return match.len != 0; - } - - boolean insertAndFindWiderMatch(ByteBuffer buf, int off, int startLimit, int matchLimit, int minLen, Match match) { - match.len = minLen; - - insert(off, buf); - - final int delta = off - startLimit; - int ref = hashPointer(buf, off); - for (int i = 0; i < maxAttempts; ++i) { - if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { - break; - } - if (LZ4ByteBufferUtils.readIntEquals(buf, ref, off)) { - final int matchLenForward = MIN_MATCH +LZ4ByteBufferUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); - final int matchLenBackward = LZ4ByteBufferUtils.commonBytesBackward(buf, ref, off, base, startLimit); - final int matchLen = matchLenBackward + matchLenForward; - if (matchLen > match.len) { - match.len = matchLen; - match.ref = ref - matchLenBackward; - match.start = off - matchLenBackward; - } - } - ref = next(ref); - } - - return match.len > minLen; - } - - - } - - @Override - public int compress(byte[] src, int srcOff, int srcLen, byte[] dest, int destOff, int maxDestLen) { - - UnsafeUtils.checkRange(src, srcOff, srcLen); - UnsafeUtils.checkRange(dest, destOff, maxDestLen); - - final int srcEnd = srcOff + srcLen; - final int destEnd = destOff + maxDestLen; - final int mfLimit = srcEnd - MF_LIMIT; - final int matchLimit = srcEnd - LAST_LITERALS; - - int sOff = srcOff; - int dOff = destOff; - int anchor = sOff++; - - final HashTable ht = new HashTable(srcOff); - final Match match0 = new Match(); - final Match match1 = new Match(); - final Match match2 = new Match(); - final Match match3 = new Match(); - - main: - while (sOff < mfLimit) { - if (!ht.insertAndFindBestMatch(src, sOff, matchLimit, match1)) { - ++sOff; - continue; - } - - // saved, in case we would skip too much - copyTo(match1, match0); - - search2: - while (true) { - assert match1.start >= anchor; - if (match1.end() >= mfLimit - || !ht.insertAndFindWiderMatch(src, match1.end() - 2, match1.start + 1, matchLimit, match1.len, match2)) { - // no better match - dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - continue main; + HashTable(int base) { + this.base = base; + nextToUpdate = base; + hashTable = new int[HASH_TABLE_SIZE_HC]; + Arrays.fill(hashTable, -1); + chainTable = new short[MAX_DISTANCE]; } - if (match0.start < match1.start) { - if (match2.start < match1.start + match0.len) { // empirical - copyTo(match0, match1); - } - } - assert match2.start > match1.start; - - if (match2.start - match1.start < 3) { // First Match too small : removed - copyTo(match2, match1); - continue search2; + private int hashPointer(byte[] bytes, int off) { + final int v = UnsafeUtils.readInt(bytes, off); + return hashPointer(v); } - search3: - while (true) { - if (match2.start - match1.start < OPTIMAL_ML) { - int newMatchLen = match1.len; - if (newMatchLen > OPTIMAL_ML) { - newMatchLen = OPTIMAL_ML; + private int hashPointer(ByteBuffer bytes, int off) { + final int v = ByteBufferUtils.readInt(bytes, off); + return hashPointer(v); + } + + private int hashPointer(int v) { + final int h = hashHC(v); + return hashTable[h]; + } + + private int next(int off) { + return off - (chainTable[off & MASK] & 0xFFFF); + } + + private void addHash(byte[] bytes, int off) { + final int v = UnsafeUtils.readInt(bytes, off); + addHash(v, off); + } + + private void addHash(ByteBuffer bytes, int off) { + final int v = ByteBufferUtils.readInt(bytes, off); + addHash(v, off); + } + + private void addHash(int v, int off) { + final int h = hashHC(v); + int delta = off - hashTable[h]; + assert delta > 0 : delta; + if (delta >= MAX_DISTANCE) { + delta = MAX_DISTANCE - 1; } - if (match1.start + newMatchLen > match2.end() - MIN_MATCH) { - newMatchLen = match2.start - match1.start + match2.len - MIN_MATCH; - } - final int correction = newMatchLen - (match2.start - match1.start); - if (correction > 0) { - match2.fix(correction); - } - } + chainTable[off & MASK] = (short) delta; + hashTable[h] = off; + } - if (match2.start + match2.len >= mfLimit - || !ht.insertAndFindWiderMatch(src, match2.end() - 3, match2.start, matchLimit, match2.len, match3)) { - // no better match -> 2 sequences to encode - if (match2.start < match1.end()) { - match1.len = match2.start - match1.start; + void insert(int off, byte[] bytes) { + for (; nextToUpdate < off; ++nextToUpdate) { + addHash(bytes, nextToUpdate); } - // encode seq 1 - dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - // encode seq 2 - dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match2.start, match2.ref, match2.len, dest, dOff, destEnd); - anchor = sOff = match2.end(); - continue main; - } + } - if (match3.start < match1.end() + 3) { // Not enough space for match 2 : remove it - if (match3.start >= match1.end()) { // // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 - if (match2.start < match1.end()) { - final int correction = match1.end() - match2.start; - match2.fix(correction); - if (match2.len < MIN_MATCH) { - copyTo(match3, match2); + void insert(int off, ByteBuffer bytes) { + for (; nextToUpdate < off; ++nextToUpdate) { + addHash(bytes, nextToUpdate); + } + } + + + boolean insertAndFindBestMatch(byte[] buf, int off, int matchLimit, Match match) { + match.start = off; + match.len = 0; + int delta = 0; + int repl = 0; + + insert(off, buf); + + int ref = hashPointer(buf, off); + + if (ref >= off - 4 && ref <= off && ref >= base) { // potential repetition + if (LZ4UnsafeUtils.readIntEquals(buf, ref, off)) { // confirmed + delta = off - ref; + repl = match.len = MIN_MATCH + LZ4UnsafeUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); + match.ref = ref; } - } - - dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - - copyTo(match3, match1); - copyTo(match2, match0); - - continue search2; + ref = next(ref); } - copyTo(match3, match2); - continue search3; - } - - // OK, now we have 3 ascending matches; let's write at least the first one - if (match2.start < match1.end()) { - if (match2.start - match1.start < ML_MASK) { - if (match1.len > OPTIMAL_ML) { - match1.len = OPTIMAL_ML; - } - if (match1.end() > match2.end() - MIN_MATCH) { - match1.len = match2.end() - match1.start - MIN_MATCH; - } - final int correction = match1.end() - match2.start; - match2.fix(correction); - } else { - match1.len = match2.start - match1.start; - } - } - - dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - - copyTo(match2, match1); - copyTo(match3, match2); - - continue search3; - } - - } - - } - - dOff = LZ4UnsafeUtils.lastLiterals(src, anchor, srcEnd - anchor, dest, dOff, destEnd); - return dOff - destOff; - } - - - @Override - public int compress(ByteBuffer src, int srcOff, int srcLen, ByteBuffer dest, int destOff, int maxDestLen) { - - if (src.hasArray() && dest.hasArray()) { - return compress(src.array(), srcOff + src.arrayOffset(), srcLen, dest.array(), destOff + dest.arrayOffset(), maxDestLen); - } - src = ByteBufferUtils.inNativeByteOrder(src); - dest = ByteBufferUtils.inNativeByteOrder(dest); - - ByteBufferUtils.checkRange(src, srcOff, srcLen); - ByteBufferUtils.checkRange(dest, destOff, maxDestLen); - - final int srcEnd = srcOff + srcLen; - final int destEnd = destOff + maxDestLen; - final int mfLimit = srcEnd - MF_LIMIT; - final int matchLimit = srcEnd - LAST_LITERALS; - - int sOff = srcOff; - int dOff = destOff; - int anchor = sOff++; - - final HashTable ht = new HashTable(srcOff); - final Match match0 = new Match(); - final Match match1 = new Match(); - final Match match2 = new Match(); - final Match match3 = new Match(); - - main: - while (sOff < mfLimit) { - if (!ht.insertAndFindBestMatch(src, sOff, matchLimit, match1)) { - ++sOff; - continue; - } - - // saved, in case we would skip too much - copyTo(match1, match0); - - search2: - while (true) { - assert match1.start >= anchor; - if (match1.end() >= mfLimit - || !ht.insertAndFindWiderMatch(src, match1.end() - 2, match1.start + 1, matchLimit, match1.len, match2)) { - // no better match - dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - continue main; - } - - if (match0.start < match1.start) { - if (match2.start < match1.start + match0.len) { // empirical - copyTo(match0, match1); - } - } - assert match2.start > match1.start; - - if (match2.start - match1.start < 3) { // First Match too small : removed - copyTo(match2, match1); - continue search2; - } - - search3: - while (true) { - if (match2.start - match1.start < OPTIMAL_ML) { - int newMatchLen = match1.len; - if (newMatchLen > OPTIMAL_ML) { - newMatchLen = OPTIMAL_ML; - } - if (match1.start + newMatchLen > match2.end() - MIN_MATCH) { - newMatchLen = match2.start - match1.start + match2.len - MIN_MATCH; - } - final int correction = newMatchLen - (match2.start - match1.start); - if (correction > 0) { - match2.fix(correction); - } - } - - if (match2.start + match2.len >= mfLimit - || !ht.insertAndFindWiderMatch(src, match2.end() - 3, match2.start, matchLimit, match2.len, match3)) { - // no better match -> 2 sequences to encode - if (match2.start < match1.end()) { - match1.len = match2.start - match1.start; - } - // encode seq 1 - dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - // encode seq 2 - dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match2.start, match2.ref, match2.len, dest, dOff, destEnd); - anchor = sOff = match2.end(); - continue main; - } - - if (match3.start < match1.end() + 3) { // Not enough space for match 2 : remove it - if (match3.start >= match1.end()) { // // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 - if (match2.start < match1.end()) { - final int correction = match1.end() - match2.start; - match2.fix(correction); - if (match2.len < MIN_MATCH) { - copyTo(match3, match2); + for (int i = 0; i < maxAttempts; ++i) { + if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { + break; } - } - - dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - - copyTo(match3, match1); - copyTo(match2, match0); - - continue search2; + if (LZ4UnsafeUtils.readIntEquals(buf, ref, off)) { + final int matchLen = MIN_MATCH + LZ4UnsafeUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); + if (matchLen > match.len) { + match.ref = ref; + match.len = matchLen; + } + } + ref = next(ref); } - copyTo(match3, match2); - continue search3; - } - - // OK, now we have 3 ascending matches; let's write at least the first one - if (match2.start < match1.end()) { - if (match2.start - match1.start < ML_MASK) { - if (match1.len > OPTIMAL_ML) { - match1.len = OPTIMAL_ML; - } - if (match1.end() > match2.end() - MIN_MATCH) { - match1.len = match2.end() - match1.start - MIN_MATCH; - } - final int correction = match1.end() - match2.start; - match2.fix(correction); - } else { - match1.len = match2.start - match1.start; + if (repl != 0) { + int ptr = off; + final int end = off + repl - (MIN_MATCH - 1); + while (ptr < end - delta) { + chainTable[ptr & MASK] = (short) delta; // pre load + ++ptr; + } + do { + chainTable[ptr & MASK] = (short) delta; + hashTable[hashHC(UnsafeUtils.readInt(buf, ptr))] = ptr; + ++ptr; + } while (ptr < end); + nextToUpdate = end; } - } - dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); - anchor = sOff = match1.end(); - - copyTo(match2, match1); - copyTo(match3, match2); - - continue search3; + return match.len != 0; + } + + boolean insertAndFindWiderMatch(byte[] buf, int off, int startLimit, int matchLimit, int minLen, Match match) { + match.len = minLen; + + insert(off, buf); + + final int delta = off - startLimit; + int ref = hashPointer(buf, off); + for (int i = 0; i < maxAttempts; ++i) { + if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { + break; + } + if (LZ4UnsafeUtils.readIntEquals(buf, ref, off)) { + final int matchLenForward = MIN_MATCH + LZ4UnsafeUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); + final int matchLenBackward = LZ4UnsafeUtils.commonBytesBackward(buf, ref, off, base, startLimit); + final int matchLen = matchLenBackward + matchLenForward; + if (matchLen > match.len) { + match.len = matchLen; + match.ref = ref - matchLenBackward; + match.start = off - matchLenBackward; + } + } + ref = next(ref); + } + + return match.len > minLen; + } + + + boolean insertAndFindBestMatch(ByteBuffer buf, int off, int matchLimit, Match match) { + match.start = off; + match.len = 0; + int delta = 0; + int repl = 0; + + insert(off, buf); + + int ref = hashPointer(buf, off); + + if (ref >= off - 4 && ref <= off && ref >= base) { // potential repetition + if (LZ4ByteBufferUtils.readIntEquals(buf, ref, off)) { // confirmed + delta = off - ref; + repl = match.len = MIN_MATCH + LZ4ByteBufferUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); + match.ref = ref; + } + ref = next(ref); + } + + for (int i = 0; i < maxAttempts; ++i) { + if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { + break; + } + if (LZ4ByteBufferUtils.readIntEquals(buf, ref, off)) { + final int matchLen = MIN_MATCH + LZ4ByteBufferUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); + if (matchLen > match.len) { + match.ref = ref; + match.len = matchLen; + } + } + ref = next(ref); + } + + if (repl != 0) { + int ptr = off; + final int end = off + repl - (MIN_MATCH - 1); + while (ptr < end - delta) { + chainTable[ptr & MASK] = (short) delta; // pre load + ++ptr; + } + do { + chainTable[ptr & MASK] = (short) delta; + hashTable[hashHC(ByteBufferUtils.readInt(buf, ptr))] = ptr; + ++ptr; + } while (ptr < end); + nextToUpdate = end; + } + + return match.len != 0; + } + + boolean insertAndFindWiderMatch(ByteBuffer buf, int off, int startLimit, int matchLimit, int minLen, Match match) { + match.len = minLen; + + insert(off, buf); + + final int delta = off - startLimit; + int ref = hashPointer(buf, off); + for (int i = 0; i < maxAttempts; ++i) { + if (ref < Math.max(base, off - MAX_DISTANCE + 1) || ref > off) { + break; + } + if (LZ4ByteBufferUtils.readIntEquals(buf, ref, off)) { + final int matchLenForward = MIN_MATCH + LZ4ByteBufferUtils.commonBytes(buf, ref + MIN_MATCH, off + MIN_MATCH, matchLimit); + final int matchLenBackward = LZ4ByteBufferUtils.commonBytesBackward(buf, ref, off, base, startLimit); + final int matchLen = matchLenBackward + matchLenForward; + if (matchLen > match.len) { + match.len = matchLen; + match.ref = ref - matchLenBackward; + match.start = off - matchLenBackward; + } + } + ref = next(ref); + } + + return match.len > minLen; } - } } - dOff = LZ4ByteBufferUtils.lastLiterals(src, anchor, srcEnd - anchor, dest, dOff, destEnd); - return dOff - destOff; - } + @Override + public int compress(byte[] src, int srcOff, int srcLen, byte[] dest, int destOff, int maxDestLen) { + + UnsafeUtils.checkRange(src, srcOff, srcLen); + UnsafeUtils.checkRange(dest, destOff, maxDestLen); + + final int srcEnd = srcOff + srcLen; + final int destEnd = destOff + maxDestLen; + final int mfLimit = srcEnd - MF_LIMIT; + final int matchLimit = srcEnd - LAST_LITERALS; + + int sOff = srcOff; + int dOff = destOff; + int anchor = sOff++; + + final HashTable ht = new HashTable(srcOff); + final Match match0 = new Match(); + final Match match1 = new Match(); + final Match match2 = new Match(); + final Match match3 = new Match(); + + main: + while (sOff < mfLimit) { + if (!ht.insertAndFindBestMatch(src, sOff, matchLimit, match1)) { + ++sOff; + continue; + } + + // saved, in case we would skip too much + copyTo(match1, match0); + + search2: + while (true) { + assert match1.start >= anchor; + if (match1.end() >= mfLimit + || !ht.insertAndFindWiderMatch(src, match1.end() - 2, match1.start + 1, matchLimit, match1.len, match2)) { + // no better match + dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + continue main; + } + + if (match0.start < match1.start) { + if (match2.start < match1.start + match0.len) { // empirical + copyTo(match0, match1); + } + } + assert match2.start > match1.start; + + if (match2.start - match1.start < 3) { // First Match too small : removed + copyTo(match2, match1); + continue search2; + } + + search3: + while (true) { + if (match2.start - match1.start < OPTIMAL_ML) { + int newMatchLen = match1.len; + if (newMatchLen > OPTIMAL_ML) { + newMatchLen = OPTIMAL_ML; + } + if (match1.start + newMatchLen > match2.end() - MIN_MATCH) { + newMatchLen = match2.start - match1.start + match2.len - MIN_MATCH; + } + final int correction = newMatchLen - (match2.start - match1.start); + if (correction > 0) { + match2.fix(correction); + } + } + + if (match2.start + match2.len >= mfLimit + || !ht.insertAndFindWiderMatch(src, match2.end() - 3, match2.start, matchLimit, match2.len, match3)) { + // no better match -> 2 sequences to encode + if (match2.start < match1.end()) { + match1.len = match2.start - match1.start; + } + // encode seq 1 + dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + // encode seq 2 + dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match2.start, match2.ref, match2.len, dest, dOff, destEnd); + anchor = sOff = match2.end(); + continue main; + } + + if (match3.start < match1.end() + 3) { // Not enough space for match 2 : remove it + if (match3.start >= match1.end()) { // // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 + if (match2.start < match1.end()) { + final int correction = match1.end() - match2.start; + match2.fix(correction); + if (match2.len < MIN_MATCH) { + copyTo(match3, match2); + } + } + + dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + + copyTo(match3, match1); + copyTo(match2, match0); + + continue search2; + } + + copyTo(match3, match2); + continue search3; + } + + // OK, now we have 3 ascending matches; let's write at least the first one + if (match2.start < match1.end()) { + if (match2.start - match1.start < ML_MASK) { + if (match1.len > OPTIMAL_ML) { + match1.len = OPTIMAL_ML; + } + if (match1.end() > match2.end() - MIN_MATCH) { + match1.len = match2.end() - match1.start - MIN_MATCH; + } + final int correction = match1.end() - match2.start; + match2.fix(correction); + } else { + match1.len = match2.start - match1.start; + } + } + + dOff = LZ4UnsafeUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + + copyTo(match2, match1); + copyTo(match3, match2); + + continue search3; + } + + } + + } + + dOff = LZ4UnsafeUtils.lastLiterals(src, anchor, srcEnd - anchor, dest, dOff, destEnd); + return dOff - destOff; + } + + + @Override + public int compress(ByteBuffer src, int srcOff, int srcLen, ByteBuffer dest, int destOff, int maxDestLen) { + + if (src.hasArray() && dest.hasArray()) { + return compress(src.array(), srcOff + src.arrayOffset(), srcLen, dest.array(), destOff + dest.arrayOffset(), maxDestLen); + } + src = ByteBufferUtils.inNativeByteOrder(src); + dest = ByteBufferUtils.inNativeByteOrder(dest); + + ByteBufferUtils.checkRange(src, srcOff, srcLen); + ByteBufferUtils.checkRange(dest, destOff, maxDestLen); + + final int srcEnd = srcOff + srcLen; + final int destEnd = destOff + maxDestLen; + final int mfLimit = srcEnd - MF_LIMIT; + final int matchLimit = srcEnd - LAST_LITERALS; + + int sOff = srcOff; + int dOff = destOff; + int anchor = sOff++; + + final HashTable ht = new HashTable(srcOff); + final Match match0 = new Match(); + final Match match1 = new Match(); + final Match match2 = new Match(); + final Match match3 = new Match(); + + main: + while (sOff < mfLimit) { + if (!ht.insertAndFindBestMatch(src, sOff, matchLimit, match1)) { + ++sOff; + continue; + } + + // saved, in case we would skip too much + copyTo(match1, match0); + + search2: + while (true) { + assert match1.start >= anchor; + if (match1.end() >= mfLimit + || !ht.insertAndFindWiderMatch(src, match1.end() - 2, match1.start + 1, matchLimit, match1.len, match2)) { + // no better match + dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + continue main; + } + + if (match0.start < match1.start) { + if (match2.start < match1.start + match0.len) { // empirical + copyTo(match0, match1); + } + } + assert match2.start > match1.start; + + if (match2.start - match1.start < 3) { // First Match too small : removed + copyTo(match2, match1); + continue search2; + } + + search3: + while (true) { + if (match2.start - match1.start < OPTIMAL_ML) { + int newMatchLen = match1.len; + if (newMatchLen > OPTIMAL_ML) { + newMatchLen = OPTIMAL_ML; + } + if (match1.start + newMatchLen > match2.end() - MIN_MATCH) { + newMatchLen = match2.start - match1.start + match2.len - MIN_MATCH; + } + final int correction = newMatchLen - (match2.start - match1.start); + if (correction > 0) { + match2.fix(correction); + } + } + + if (match2.start + match2.len >= mfLimit + || !ht.insertAndFindWiderMatch(src, match2.end() - 3, match2.start, matchLimit, match2.len, match3)) { + // no better match -> 2 sequences to encode + if (match2.start < match1.end()) { + match1.len = match2.start - match1.start; + } + // encode seq 1 + dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + // encode seq 2 + dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match2.start, match2.ref, match2.len, dest, dOff, destEnd); + anchor = sOff = match2.end(); + continue main; + } + + if (match3.start < match1.end() + 3) { // Not enough space for match 2 : remove it + if (match3.start >= match1.end()) { // // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 + if (match2.start < match1.end()) { + final int correction = match1.end() - match2.start; + match2.fix(correction); + if (match2.len < MIN_MATCH) { + copyTo(match3, match2); + } + } + + dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + + copyTo(match3, match1); + copyTo(match2, match0); + + continue search2; + } + + copyTo(match3, match2); + continue search3; + } + + // OK, now we have 3 ascending matches; let's write at least the first one + if (match2.start < match1.end()) { + if (match2.start - match1.start < ML_MASK) { + if (match1.len > OPTIMAL_ML) { + match1.len = OPTIMAL_ML; + } + if (match1.end() > match2.end() - MIN_MATCH) { + match1.len = match2.end() - match1.start - MIN_MATCH; + } + final int correction = match1.end() - match2.start; + match2.fix(correction); + } else { + match1.len = match2.start - match1.start; + } + } + + dOff = LZ4ByteBufferUtils.encodeSequence(src, anchor, match1.start, match1.ref, match1.len, dest, dOff, destEnd); + anchor = sOff = match1.end(); + + copyTo(match2, match1); + copyTo(match3, match2); + + continue search3; + } + + } + + } + + dOff = LZ4ByteBufferUtils.lastLiterals(src, anchor, srcEnd - anchor, dest, dOff, destEnd); + return dOff - destOff; + } } diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JNI.java b/core/src/main/java/net/jpountz/lz4/LZ4JNI.java index f083319a..9ca38667 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JNI.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JNI.java @@ -15,7 +15,6 @@ package net.jpountz.lz4; */ import java.nio.ByteBuffer; - import net.jpountz.util.Native; diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JNICompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JNICompressor.java index 18971a33..ba0c047d 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JNICompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JNICompressor.java @@ -14,12 +14,13 @@ package net.jpountz.lz4; * limitations under the License. */ +import java.nio.ByteBuffer; + + import static net.jpountz.util.ByteBufferUtils.checkNotReadOnly; import static net.jpountz.util.ByteBufferUtils.checkRange; import static net.jpountz.util.SafeUtils.checkRange; -import java.nio.ByteBuffer; - /** * Fast {@link LZ4FastCompressor}s implemented with JNI bindings to the original C * implementation of LZ4. diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JNIFastDecompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JNIFastDecompressor.java index 5c355d85..6bffba08 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JNIFastDecompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JNIFastDecompressor.java @@ -16,7 +16,6 @@ package net.jpountz.lz4; import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JNISafeDecompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JNISafeDecompressor.java index d948c988..d0404903 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JNISafeDecompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JNISafeDecompressor.java @@ -16,7 +16,6 @@ package net.jpountz.lz4; import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeCompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeCompressor.java index 06d635d6..254f2097 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeCompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeCompressor.java @@ -2,15 +2,27 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; -import static net.jpountz.lz4.LZ4Utils.*; - import java.nio.ByteBuffer; import java.util.Arrays; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; + +import static net.jpountz.lz4.LZ4Constants.HASH_TABLE_SIZE; +import static net.jpountz.lz4.LZ4Constants.HASH_TABLE_SIZE_64K; +import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; +import static net.jpountz.lz4.LZ4Constants.LZ4_64K_LIMIT; +import static net.jpountz.lz4.LZ4Constants.MAX_DISTANCE; +import static net.jpountz.lz4.LZ4Constants.MF_LIMIT; +import static net.jpountz.lz4.LZ4Constants.MIN_LENGTH; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_BITS; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.RUN_MASK; +import static net.jpountz.lz4.LZ4Constants.SKIP_STRENGTH; +import static net.jpountz.lz4.LZ4Utils.hash; +import static net.jpountz.lz4.LZ4Utils.hash64k; + /** * Compressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeFastDecompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeFastDecompressor.java index f9354d67..35278009 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeFastDecompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeFastDecompressor.java @@ -2,13 +2,17 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; - import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; + +import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_BITS; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.RUN_MASK; + /** * Decompressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeSafeDecompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeSafeDecompressor.java index 2e77203c..24625dfa 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeSafeDecompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JavaSafeSafeDecompressor.java @@ -2,13 +2,17 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; - import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.SafeUtils; + +import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_BITS; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.RUN_MASK; + /** * Decompressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeCompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeCompressor.java index b52fb521..2da8100d 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeCompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeCompressor.java @@ -2,15 +2,27 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; -import static net.jpountz.lz4.LZ4Utils.*; - import java.nio.ByteBuffer; import java.util.Arrays; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.UnsafeUtils; + +import static net.jpountz.lz4.LZ4Constants.HASH_TABLE_SIZE; +import static net.jpountz.lz4.LZ4Constants.HASH_TABLE_SIZE_64K; +import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; +import static net.jpountz.lz4.LZ4Constants.LZ4_64K_LIMIT; +import static net.jpountz.lz4.LZ4Constants.MAX_DISTANCE; +import static net.jpountz.lz4.LZ4Constants.MF_LIMIT; +import static net.jpountz.lz4.LZ4Constants.MIN_LENGTH; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_BITS; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.RUN_MASK; +import static net.jpountz.lz4.LZ4Constants.SKIP_STRENGTH; +import static net.jpountz.lz4.LZ4Utils.hash; +import static net.jpountz.lz4.LZ4Utils.hash64k; + /** * Compressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeFastDecompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeFastDecompressor.java index ca26a4a8..f29e90b3 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeFastDecompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeFastDecompressor.java @@ -2,13 +2,17 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; - import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.UnsafeUtils; + +import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_BITS; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.RUN_MASK; + /** * Decompressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeSafeDecompressor.java b/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeSafeDecompressor.java index 2bf83e51..5df579b8 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeSafeDecompressor.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4JavaUnsafeSafeDecompressor.java @@ -2,13 +2,17 @@ package net.jpountz.lz4; -import static net.jpountz.lz4.LZ4Constants.*; - import java.nio.ByteBuffer; - import net.jpountz.util.ByteBufferUtils; import net.jpountz.util.UnsafeUtils; + +import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH; +import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; +import static net.jpountz.lz4.LZ4Constants.ML_BITS; +import static net.jpountz.lz4.LZ4Constants.ML_MASK; +import static net.jpountz.lz4.LZ4Constants.RUN_MASK; + /** * Decompressor. */ diff --git a/core/src/main/java/net/jpountz/lz4/LZ4OutputStream.java b/core/src/main/java/net/jpountz/lz4/LZ4OutputStream.java index af16abab..cd7813fe 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4OutputStream.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4OutputStream.java @@ -1,7 +1,7 @@ package net.jpountz.lz4; -import java.io.OutputStream; import java.io.IOException; +import java.io.OutputStream; public class LZ4OutputStream extends OutputStream { private static final LZ4Factory lz4Factory = LZ4Factory.fastestInstance(); diff --git a/core/src/main/java/net/jpountz/lz4/LZ4SafeUtils.java b/core/src/main/java/net/jpountz/lz4/LZ4SafeUtils.java index 7842bd77..66ffc807 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4SafeUtils.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4SafeUtils.java @@ -14,11 +14,13 @@ package net.jpountz.lz4; * limitations under the License. */ +import net.jpountz.util.SafeUtils; + + import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; import static net.jpountz.lz4.LZ4Constants.ML_BITS; import static net.jpountz.lz4.LZ4Constants.ML_MASK; import static net.jpountz.lz4.LZ4Constants.RUN_MASK; -import net.jpountz.util.SafeUtils; enum LZ4SafeUtils { ; diff --git a/core/src/main/java/net/jpountz/lz4/LZ4StreamHelper.java b/core/src/main/java/net/jpountz/lz4/LZ4StreamHelper.java index 1f42692f..cce21c58 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4StreamHelper.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4StreamHelper.java @@ -1,8 +1,8 @@ package net.jpountz.lz4; +import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; -import java.io.IOException; public class LZ4StreamHelper { static void writeLength(int length, OutputStream os) throws IOException { diff --git a/core/src/main/java/net/jpountz/lz4/LZ4StreamTest.java b/core/src/main/java/net/jpountz/lz4/LZ4StreamTest.java index ca2d7cf7..d3d270f2 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4StreamTest.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4StreamTest.java @@ -1,18 +1,17 @@ package net.jpountz.lz4; -import static junit.framework.Assert.assertEquals; - import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Random; - import junit.framework.Assert; - import org.junit.Before; import org.junit.Test; + +import static junit.framework.Assert.assertEquals; + public class LZ4StreamTest { private long seed; diff --git a/core/src/main/java/net/jpountz/util/LZ4UnsafeUtils.java b/core/src/main/java/net/jpountz/lz4/LZ4UnsafeUtils.java similarity index 99% rename from core/src/main/java/net/jpountz/util/LZ4UnsafeUtils.java rename to core/src/main/java/net/jpountz/lz4/LZ4UnsafeUtils.java index a5ad7834..6eb08ab6 100644 --- a/core/src/main/java/net/jpountz/util/LZ4UnsafeUtils.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4UnsafeUtils.java @@ -14,6 +14,9 @@ package net.jpountz.lz4; * limitations under the License. */ +import java.nio.ByteOrder; + + import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH; import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; import static net.jpountz.lz4.LZ4Constants.ML_BITS; @@ -29,8 +32,6 @@ import static net.jpountz.util.UnsafeUtils.writeLong; import static net.jpountz.util.UnsafeUtils.writeShort; import static net.jpountz.util.Utils.NATIVE_BYTE_ORDER; -import java.nio.ByteOrder; - enum LZ4UnsafeUtils { ; diff --git a/core/src/main/java/net/jpountz/lz4/LZ4Utils.java b/core/src/main/java/net/jpountz/lz4/LZ4Utils.java index a6a84d6a..5661c417 100644 --- a/core/src/main/java/net/jpountz/lz4/LZ4Utils.java +++ b/core/src/main/java/net/jpountz/lz4/LZ4Utils.java @@ -17,12 +17,7 @@ package net.jpountz.lz4; import static net.jpountz.lz4.LZ4Constants.HASH_LOG; import static net.jpountz.lz4.LZ4Constants.HASH_LOG_64K; import static net.jpountz.lz4.LZ4Constants.HASH_LOG_HC; -import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS; import static net.jpountz.lz4.LZ4Constants.MIN_MATCH; -import static net.jpountz.lz4.LZ4Constants.ML_BITS; -import static net.jpountz.lz4.LZ4Constants.ML_MASK; -import static net.jpountz.lz4.LZ4Constants.RUN_MASK; -import net.jpountz.util.SafeUtils; enum LZ4Utils { ; diff --git a/core/src/main/java/net/jpountz/util/Native.java b/core/src/main/java/net/jpountz/util/Native.java index d4a8707b..af728479 100644 --- a/core/src/main/java/net/jpountz/util/Native.java +++ b/core/src/main/java/net/jpountz/util/Native.java @@ -71,9 +71,6 @@ public enum Native { return; } String resourceName = resourceName(); - System.out.println("NAME: " + resourceName); - System.out.println("WORK: " + Fawe.class.getResourceAsStream("/LICENSE")); - System.out.println("WORK: " + Fawe.class.getResourceAsStream("/win32/amd64/liblz4-java.so")); InputStream is = Fawe.class.getResourceAsStream(resourceName); if (is == null) { throw new UnsupportedOperationException("Unsupported OS/arch, cannot find " + resourceName + ". Please try building from source."); diff --git a/core/src/main/java/net/jpountz/util/UnsafeUtils.java b/core/src/main/java/net/jpountz/util/UnsafeUtils.java index 30231ef1..6d673b9e 100644 --- a/core/src/main/java/net/jpountz/util/UnsafeUtils.java +++ b/core/src/main/java/net/jpountz/util/UnsafeUtils.java @@ -14,13 +14,13 @@ package net.jpountz.util; * limitations under the License. */ -import static net.jpountz.util.Utils.NATIVE_BYTE_ORDER; - import java.lang.reflect.Field; import java.nio.ByteOrder; - import sun.misc.Unsafe; + +import static net.jpountz.util.Utils.NATIVE_BYTE_ORDER; + public enum UnsafeUtils { ; diff --git a/core/src/main/java/net/jpountz/xxhash/AbstractStreamingXXHash32Java.java b/core/src/main/java/net/jpountz/xxhash/AbstractStreamingXXHash32Java.java deleted file mode 100644 index 3dd3ed4f..00000000 --- a/core/src/main/java/net/jpountz/xxhash/AbstractStreamingXXHash32Java.java +++ /dev/null @@ -1,42 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import static net.jpountz.xxhash.XXHashConstants.PRIME1; -import static net.jpountz.xxhash.XXHashConstants.PRIME2; - -abstract class AbstractStreamingXXHash32Java extends StreamingXXHash32 { - - int v1, v2, v3, v4, memSize; - long totalLen; - final byte[] memory; - - AbstractStreamingXXHash32Java(int seed) { - super(seed); - memory = new byte[16]; - reset(); - } - - @Override - public void reset() { - v1 = seed + PRIME1 + PRIME2; - v2 = seed + PRIME2; - v3 = seed + 0; - v4 = seed - PRIME1; - totalLen = 0; - memSize = 0; - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/AbstractStreamingXXHash64Java.java b/core/src/main/java/net/jpountz/xxhash/AbstractStreamingXXHash64Java.java deleted file mode 100644 index 97e294dd..00000000 --- a/core/src/main/java/net/jpountz/xxhash/AbstractStreamingXXHash64Java.java +++ /dev/null @@ -1,43 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import static net.jpountz.xxhash.XXHashConstants.PRIME64_1; -import static net.jpountz.xxhash.XXHashConstants.PRIME64_2; - -abstract class AbstractStreamingXXHash64Java extends StreamingXXHash64 { - - int memSize; - long v1, v2, v3, v4; - long totalLen; - final byte[] memory; - - AbstractStreamingXXHash64Java(long seed) { - super(seed); - memory = new byte[32]; - reset(); - } - - @Override - public void reset() { - v1 = seed + PRIME64_1 + PRIME64_2; - v2 = seed + PRIME64_2; - v3 = seed + 0; - v4 = seed - PRIME64_1; - totalLen = 0; - memSize = 0; - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash32.java b/core/src/main/java/net/jpountz/xxhash/StreamingXXHash32.java deleted file mode 100644 index c59f0346..00000000 --- a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash32.java +++ /dev/null @@ -1,111 +0,0 @@ -package net.jpountz.xxhash; - -import java.util.zip.Checksum; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - - -/** - * Streaming interface for {@link XXHash32}. - *
syncFlush=true
- * This API is compatible with the {@link XXHash32 block API} and the following - * code samples are equivalent: - *
- * int hash(XXHashFactory xxhashFactory, byte[] buf, int off, int len, int seed) { - * return xxhashFactory.hash32().hash(buf, off, len, seed); - * } - *
- * int hash(XXHashFactory xxhashFactory, byte[] buf, int off, int len, int seed) { - * StreamingXXHash32 sh32 = xxhashFactory.newStreamingHash32(seed); - * sh32.update(buf, off, len); - * return sh32.getValue(); - * } - *
- * Instances of this class are not thread-safe. - */ -public abstract class StreamingXXHash32 { - - interface Factory { - - StreamingXXHash32 newStreamingHash(int seed); - - } - - final int seed; - - StreamingXXHash32(int seed) { - this.seed = seed; - } - - /** - * Get the value of the checksum. - */ - public abstract int getValue(); - - /** - * Update the value of the hash with buf[off:off+len]. - */ - public abstract void update(byte[] buf, int off, int len); - - /** - * Reset this instance to the state it had right after instantiation. The - * seed remains unchanged. - */ - public abstract void reset(); - - @Override - public String toString() { - return getClass().getSimpleName() + "(seed=" + seed + ")"; - } - - /** - * Return a {@link Checksum} view of this instance. Modifications to the view - * will modify this instance too and vice-versa. - */ - public final Checksum asChecksum() { - return new Checksum() { - - @Override - public long getValue() { - return StreamingXXHash32.this.getValue() & 0xFFFFFFFL; - } - - @Override - public void reset() { - StreamingXXHash32.this.reset(); - } - - @Override - public void update(int b) { - StreamingXXHash32.this.update(new byte[] {(byte) b}, 0, 1); - } - - @Override - public void update(byte[] b, int off, int len) { - StreamingXXHash32.this.update(b, off, len); - } - - @Override - public String toString() { - return StreamingXXHash32.this.toString(); - } - - }; - } - -} \ No newline at end of file diff --git a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash32JNI.java b/core/src/main/java/net/jpountz/xxhash/StreamingXXHash32JNI.java deleted file mode 100644 index e9b58fb4..00000000 --- a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash32JNI.java +++ /dev/null @@ -1,71 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - -final class StreamingXXHash32JNI extends StreamingXXHash32 { - - static class Factory implements StreamingXXHash32.Factory { - - public static final StreamingXXHash32.Factory INSTANCE = new Factory(); - - @Override - public StreamingXXHash32 newStreamingHash(int seed) { - return new StreamingXXHash32JNI(seed); - } - - } - - private long state; - - StreamingXXHash32JNI(int seed) { - super(seed); - state = XXHashJNI.XXH32_init(seed); - } - - private void checkState() { - if (state == 0) { - throw new AssertionError("Already finalized"); - } - } - - @Override - public void reset() { - checkState(); - XXHashJNI.XXH32_free(state); - state = XXHashJNI.XXH32_init(seed); - } - - @Override - public int getValue() { - checkState(); - return XXHashJNI.XXH32_digest(state); - } - - @Override - public void update(byte[] bytes, int off, int len) { - checkState(); - XXHashJNI.XXH32_update(state, bytes, off, len); - } - - @Override - protected void finalize() throws Throwable { - super.finalize(); - // free memory - XXHashJNI.XXH32_free(state); - state = 0; - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash64.java b/core/src/main/java/net/jpountz/xxhash/StreamingXXHash64.java deleted file mode 100644 index c68fb4d1..00000000 --- a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash64.java +++ /dev/null @@ -1,111 +0,0 @@ -package net.jpountz.xxhash; - -import java.util.zip.Checksum; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - - -/** - * Streaming interface for {@link XXHash64}. - *
- * This API is compatible with the {@link XXHash64 block API} and the following - * code samples are equivalent: - *
- * long hash(XXHashFactory xxhashFactory, byte[] buf, int off, int len, long seed) { - * return xxhashFactory.hash64().hash(buf, off, len, seed); - * } - *
- * long hash(XXHashFactory xxhashFactory, byte[] buf, int off, int len, long seed) { - * StreamingXXHash64 sh64 = xxhashFactory.newStreamingHash64(seed); - * sh64.update(buf, off, len); - * return sh64.getValue(); - * } - *
- * Instances of this class are not thread-safe. - */ -public abstract class StreamingXXHash64 { - - interface Factory { - - StreamingXXHash64 newStreamingHash(long seed); - - } - - final long seed; - - StreamingXXHash64(long seed) { - this.seed = seed; - } - - /** - * Get the value of the checksum. - */ - public abstract long getValue(); - - /** - * Update the value of the hash with buf[off:off+len]. - */ - public abstract void update(byte[] buf, int off, int len); - - /** - * Reset this instance to the state it had right after instantiation. The - * seed remains unchanged. - */ - public abstract void reset(); - - @Override - public String toString() { - return getClass().getSimpleName() + "(seed=" + seed + ")"; - } - - /** - * Return a {@link Checksum} view of this instance. Modifications to the view - * will modify this instance too and vice-versa. - */ - public final Checksum asChecksum() { - return new Checksum() { - - @Override - public long getValue() { - return StreamingXXHash64.this.getValue(); - } - - @Override - public void reset() { - StreamingXXHash64.this.reset(); - } - - @Override - public void update(int b) { - StreamingXXHash64.this.update(new byte[] {(byte) b}, 0, 1); - } - - @Override - public void update(byte[] b, int off, int len) { - StreamingXXHash64.this.update(b, off, len); - } - - @Override - public String toString() { - return StreamingXXHash64.this.toString(); - } - - }; - } - -} \ No newline at end of file diff --git a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash64JNI.java b/core/src/main/java/net/jpountz/xxhash/StreamingXXHash64JNI.java deleted file mode 100644 index b7ab1acd..00000000 --- a/core/src/main/java/net/jpountz/xxhash/StreamingXXHash64JNI.java +++ /dev/null @@ -1,71 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - -final class StreamingXXHash64JNI extends StreamingXXHash64 { - - static class Factory implements StreamingXXHash64.Factory { - - public static final StreamingXXHash64.Factory INSTANCE = new Factory(); - - @Override - public StreamingXXHash64 newStreamingHash(long seed) { - return new StreamingXXHash64JNI(seed); - } - - } - - private long state; - - StreamingXXHash64JNI(long seed) { - super(seed); - state = XXHashJNI.XXH64_init(seed); - } - - private void checkState() { - if (state == 0) { - throw new AssertionError("Already finalized"); - } - } - - @Override - public void reset() { - checkState(); - XXHashJNI.XXH64_free(state); - state = XXHashJNI.XXH64_init(seed); - } - - @Override - public long getValue() { - checkState(); - return XXHashJNI.XXH64_digest(state); - } - - @Override - public void update(byte[] bytes, int off, int len) { - checkState(); - XXHashJNI.XXH64_update(state, bytes, off, len); - } - - @Override - protected void finalize() throws Throwable { - super.finalize(); - // free memory - XXHashJNI.XXH64_free(state); - state = 0; - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHash32.java b/core/src/main/java/net/jpountz/xxhash/XXHash32.java deleted file mode 100644 index 5d211436..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHash32.java +++ /dev/null @@ -1,55 +0,0 @@ -package net.jpountz.xxhash; - -import java.nio.ByteBuffer; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * A 32-bits hash. - *
- * Instances of this class are thread-safe. - */ -public abstract class XXHash32 { - - /** - * Compute the 32-bits hash of buf[off:off+len] using seed - * seed. - */ - public abstract int hash(byte[] buf, int off, int len, int seed); - - /** - * Compute the hash of the given slice of the {@link ByteBuffer}. - * {@link ByteBuffer#position() position} and {@link ByteBuffer#limit() limit} - * are not modified. - */ - public abstract int hash(ByteBuffer buf, int off, int len, int seed); - - /** - * Compute the hash of the given {@link ByteBuffer}. The - * {@link ByteBuffer#position() position} is moved in order to reflect bytes - * which have been read. - */ - public final int hash(ByteBuffer buf, int seed) { - final int hash = hash(buf, buf.position(), buf.remaining(), seed); - buf.position(buf.limit()); - return hash; - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHash32JNI.java b/core/src/main/java/net/jpountz/xxhash/XXHash32JNI.java deleted file mode 100644 index 4b713d11..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHash32JNI.java +++ /dev/null @@ -1,49 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import static net.jpountz.util.ByteBufferUtils.checkRange; -import static net.jpountz.util.SafeUtils.checkRange; - -import java.nio.ByteBuffer; - -final class XXHash32JNI extends XXHash32 { - - public static final XXHash32 INSTANCE = new XXHash32JNI(); - private static XXHash32 SAFE_INSTANCE; - - @Override - public int hash(byte[] buf, int off, int len, int seed) { - checkRange(buf, off, len); - return XXHashJNI.XXH32(buf, off, len, seed); - } - - @Override - public int hash(ByteBuffer buf, int off, int len, int seed) { - if (buf.isDirect()) { - checkRange(buf, off, len); - return XXHashJNI.XXH32BB(buf, off, len, seed); - } else if (buf.hasArray()) { - return hash(buf.array(), off + buf.arrayOffset(), len, seed); - } else { - XXHash32 safeInstance = SAFE_INSTANCE; - if (safeInstance == null) { - safeInstance = SAFE_INSTANCE = XXHashFactory.safeInstance().hash32(); - } - return safeInstance.hash(buf, off, len, seed); - } - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHash64.java b/core/src/main/java/net/jpountz/xxhash/XXHash64.java deleted file mode 100644 index 3ab73ddc..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHash64.java +++ /dev/null @@ -1,55 +0,0 @@ -package net.jpountz.xxhash; - -import java.nio.ByteBuffer; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * A 64-bits hash. - *
buf[off:off+len]
seed
- * Instances of this class are thread-safe. - */ -public abstract class XXHash64 { - - /** - * Compute the 64-bits hash of buf[off:off+len] using seed - * seed. - */ - public abstract long hash(byte[] buf, int off, int len, long seed); - - /** - * Compute the hash of the given slice of the {@link ByteBuffer}. - * {@link ByteBuffer#position() position} and {@link ByteBuffer#limit() limit} - * are not modified. - */ - public abstract long hash(ByteBuffer buf, int off, int len, long seed); - - /** - * Compute the hash of the given {@link ByteBuffer}. The - * {@link ByteBuffer#position() position} is moved in order to reflect bytes - * which have been read. - */ - public final long hash(ByteBuffer buf, long seed) { - final long hash = hash(buf, buf.position(), buf.remaining(), seed); - buf.position(buf.limit()); - return hash; - } - - @Override - public String toString() { - return getClass().getSimpleName(); - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHash64JNI.java b/core/src/main/java/net/jpountz/xxhash/XXHash64JNI.java deleted file mode 100644 index d952e1e5..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHash64JNI.java +++ /dev/null @@ -1,49 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import static net.jpountz.util.ByteBufferUtils.checkRange; -import static net.jpountz.util.SafeUtils.checkRange; - -import java.nio.ByteBuffer; - -final class XXHash64JNI extends XXHash64 { - - public static final XXHash64 INSTANCE = new XXHash64JNI(); - private static XXHash64 SAFE_INSTANCE; - - @Override - public long hash(byte[] buf, int off, int len, long seed) { - checkRange(buf, off, len); - return XXHashJNI.XXH64(buf, off, len, seed); - } - - @Override - public long hash(ByteBuffer buf, int off, int len, long seed) { - if (buf.isDirect()) { - checkRange(buf, off, len); - return XXHashJNI.XXH64BB(buf, off, len, seed); - } else if (buf.hasArray()) { - return hash(buf.array(), off + buf.arrayOffset(), len, seed); - } else { - XXHash64 safeInstance = SAFE_INSTANCE; - if (safeInstance == null) { - safeInstance = SAFE_INSTANCE = XXHashFactory.safeInstance().hash64(); - } - return safeInstance.hash(buf, off, len, seed); - } - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHashConstants.java b/core/src/main/java/net/jpountz/xxhash/XXHashConstants.java deleted file mode 100644 index 2e887dfd..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHashConstants.java +++ /dev/null @@ -1,31 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -enum XXHashConstants { - ; - - static final int PRIME1 = -1640531535; - static final int PRIME2 = -2048144777; - static final int PRIME3 = -1028477379; - static final int PRIME4 = 668265263; - static final int PRIME5 = 374761393; - - static final long PRIME64_1 = -7046029288634856825L; //11400714785074694791 - static final long PRIME64_2 = -4417276706812531889L; //14029467366897019727 - static final long PRIME64_3 = 1609587929392839161L; - static final long PRIME64_4 = -8796714831421723037L; //9650029242287828579 - static final long PRIME64_5 = 2870177450012600261L; -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHashFactory.java b/core/src/main/java/net/jpountz/xxhash/XXHashFactory.java deleted file mode 100644 index ab03dff1..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHashFactory.java +++ /dev/null @@ -1,220 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.lang.reflect.Field; -import java.util.Random; - -import net.jpountz.util.Native; -import net.jpountz.util.Utils; - -/** - * Entry point to get {@link XXHash32} and {@link StreamingXXHash32} instances. - *
- * This class has 3 instances
- * Only the {@link #safeInstance() safe instance} is guaranteed to work on your - * JVM, as a consequence it is advised to use the {@link #fastestInstance()} or - * {@link #fastestJavaInstance()} to pull a {@link XXHashFactory} instance. - *
- * All methods from this class are very costly, so you should get an instance - * once, and then reuse it whenever possible. This is typically done by storing - * a {@link XXHashFactory} instance in a static field. - */ -public final class XXHashFactory { - - private static XXHashFactory instance(String impl) { - try { - return new XXHashFactory(impl); - } catch (Exception e) { - throw new AssertionError(e); - } - } - - private static XXHashFactory NATIVE_INSTANCE, - JAVA_UNSAFE_INSTANCE, - JAVA_SAFE_INSTANCE; - - /** Return a {@link XXHashFactory} that returns {@link XXHash32} instances that - * are native bindings to the original C API. - *
- * Please note that this instance has some traps you should be aware of:
- * Please read {@link #nativeInstance() javadocs of nativeInstance()} before - * using this method. - */ - public static XXHashFactory fastestInstance() { - if (Native.isLoaded() - || Native.class.getClassLoader() == ClassLoader.getSystemClassLoader()) { - try { - return nativeInstance(); - } catch (Throwable t) { - return fastestJavaInstance(); - } - } else { - return fastestJavaInstance(); - } - } - - @SuppressWarnings("unchecked") - private static T classInstance(String cls) throws NoSuchFieldException, SecurityException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException { - ClassLoader loader = XXHashFactory.class.getClassLoader(); - loader = loader == null ? ClassLoader.getSystemClassLoader() : loader; - final Class c = loader.loadClass(cls); - Field f = c.getField("INSTANCE"); - return (T) f.get(null); - } - - private final String impl; - private final XXHash32 hash32; - private final XXHash64 hash64; - private final StreamingXXHash32.Factory streamingHash32Factory; - private final StreamingXXHash64.Factory streamingHash64Factory; - - private XXHashFactory(String impl) throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { - this.impl = impl; - hash32 = classInstance("net.jpountz.xxhash.XXHash32" + impl); - streamingHash32Factory = classInstance("net.jpountz.xxhash.StreamingXXHash32" + impl + "$Factory"); - hash64 = classInstance("net.jpountz.xxhash.XXHash64" + impl); - streamingHash64Factory = classInstance("net.jpountz.xxhash.StreamingXXHash64" + impl + "$Factory"); - - // make sure it can run - final byte[] bytes = new byte[100]; - final Random random = new Random(); - random.nextBytes(bytes); - final int seed = random.nextInt(); - - final int h1 = hash32.hash(bytes, 0, bytes.length, seed); - final StreamingXXHash32 streamingHash32 = newStreamingHash32(seed); - streamingHash32.update(bytes, 0, bytes.length); - final int h2 = streamingHash32.getValue(); - final long h3 = hash64.hash(bytes, 0, bytes.length, seed); - final StreamingXXHash64 streamingHash64 = newStreamingHash64(seed); - streamingHash64.update(bytes, 0, bytes.length); - final long h4 = streamingHash64.getValue(); - if (h1 != h2) { - throw new AssertionError(); - } - if (h3 != h4) { - throw new AssertionError(); - } - } - - /** Return a {@link XXHash32} instance. */ - public XXHash32 hash32() { - return hash32; - } - - /** Return a {@link XXHash64} instance. */ - public XXHash64 hash64() { - return hash64; - } - - /** - * Return a new {@link StreamingXXHash32} instance. - */ - public StreamingXXHash32 newStreamingHash32(int seed) { - return streamingHash32Factory.newStreamingHash(seed); - } - - /** - * Return a new {@link StreamingXXHash64} instance. - */ - public StreamingXXHash64 newStreamingHash64(long seed) { - return streamingHash64Factory.newStreamingHash(seed); - } - - /** Prints the fastest instance. */ - public static void main(String[] args) { - System.out.println("Fastest instance is " + fastestInstance()); - System.out.println("Fastest Java instance is " + fastestJavaInstance()); - } - - @Override - public String toString() { - return getClass().getSimpleName() + ":" + impl; - } - -} diff --git a/core/src/main/java/net/jpountz/xxhash/XXHashJNI.java b/core/src/main/java/net/jpountz/xxhash/XXHashJNI.java deleted file mode 100644 index 125e640b..00000000 --- a/core/src/main/java/net/jpountz/xxhash/XXHashJNI.java +++ /dev/null @@ -1,43 +0,0 @@ -package net.jpountz.xxhash; - -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import java.nio.ByteBuffer; - -import net.jpountz.util.Native; - -enum XXHashJNI { - ; - - static { - Native.load(); - init(); - } - - private static native void init(); - static native int XXH32(byte[] input, int offset, int len, int seed); - static native int XXH32BB(ByteBuffer input, int offset, int len, int seed); - static native long XXH32_init(int seed); - static native void XXH32_update(long state, byte[] input, int offset, int len); - static native int XXH32_digest(long state); - static native void XXH32_free(long state); - - static native long XXH64(byte[] input, int offset, int len, long seed); - static native long XXH64BB(ByteBuffer input, int offset, int len, long seed); - static native long XXH64_init(long seed); - static native void XXH64_update(long state, byte[] input, int offset, int len); - static native long XXH64_digest(long state); - static native void XXH64_free(long state); -} diff --git a/core/src/main/java/net/jpountz/xxhash/package.html b/core/src/main/java/net/jpountz/xxhash/package.html deleted file mode 100644 index f595d25a..00000000 --- a/core/src/main/java/net/jpountz/xxhash/package.html +++ /dev/null @@ -1,65 +0,0 @@ - - - - - - - -xxhash hashing. This package supports both block hashing via -{@link net.jpountz.xxhash.XXHash32} and streaming hashing via -{@link net.jpountz.xxhash.StreamingXXHash32}. Have a look at -{@link net.jpountz.xxhash.XXHashFactory} to know how to get instances of these -interfaces. - -Streaming hashing is a little slower but doesn't require to load the whole -stream into memory. - -Sample block usage: - - - XXHashFactory factory = XXHashFactory.fastestInstance(); - - byte[] data = "12345345234572".getBytes("UTF-8"); - - XXHash32 hash32 = factory.hash32(); - int seed = 0x9747b28c; // used to initialize the hash value, use whatever - // value you want, but always the same - int hash = hash32.hash(data, 0, data.length, seed); - - -Sample streaming usage: - - - XXHashFactory factory = XXHashFactory.fastestInstance(); - - byte[] data = "12345345234572".getBytes("UTF-8"); - ByteArrayInputStream in = new ByteArrayInputStream(data); - - int seed = 0x9747b28c; // used to initialize the hash value, use whatever - // value you want, but always the same - StreamingXXHash32 hash32 = factory.newStreamingHash32(seed); - byte[] buf = new byte[8]; // for real-world usage, use a larger buffer, like 8192 bytes - for (;;) { - int read = in.read(buf); - if (read == -1) { - break; - } - hash32.update(buf, 0, read); - } - int hash = hash32.getValue(); - - - - diff --git a/forge/.gradle/gradle.log b/forge/.gradle/gradle.log index e69de29b..d7ab305b 100644 --- a/forge/.gradle/gradle.log +++ b/forge/.gradle/gradle.log @@ -0,0 +1,89 @@ +################################################# + ForgeGradle 2.1-SNAPSHOT-unknown + https://github.com/MinecraftForge/ForgeGradle +################################################# + Powered by MCP unknown + http://modcoderpack.com + by: Searge, ProfMobius, Fesh0r, + R4wk, ZeuX, IngisKahn, bspkrs +################################################# +Version string 'unspecified' does not match SemVer specification +You should try SemVer : http://semver.org/ +:core:compileJava +:forge:deobfCompileDummyTask +:forge:deobfProvidedDummyTask +:forge:extractDependencyATs SKIPPED +:forge:extractMcpData +:core:compileJava UP-TO-DATE +:core:processResources UP-TO-DATE +:core:classes UP-TO-DATE +:core:jar UP-TO-DATE +:forge:extractMcpData SKIPPED +:forge:extractMcpMappings SKIPPED +:forge:genSrgs SKIPPED +:forge:getVersionJson +:forge:downloadServer SKIPPED +:forge:splitServerJar SKIPPED +:forge:deobfMcMCP SKIPPED +:forge:sourceApiJava UP-TO-DATE +:forge:compileApiJava UP-TO-DATE +:forge:processApiResources UP-TO-DATE +:forge:apiClasses UP-TO-DATE +:forge:sourceMainJava +:forge:compileJavaC:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'modid()' in type 'Mod': class file for net.minecraftforge.fml.common.Mod not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'name()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'version()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'acceptableRemoteVersions()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'dependencies()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'acceptedMinecraftVersions()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'value()' in type 'Instance': class file for net.minecraftforge.fml.common.Mod$Instance not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'serverSide()' in type 'SidedProxy': class file for net.minecraftforge.fml.common.SidedProxy not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'clientSide()' in type 'SidedProxy' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'modid()' in type 'Mod': class file for net.minecraftforge.fml.common.Mod not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'name()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'version()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'acceptableRemoteVersions()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'dependencies()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'acceptedMinecraftVersions()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'value()' in type 'Instance': class file for net.minecraftforge.fml.common.Mod$Instance not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'serverSide()' in type 'SidedProxy': class file for net.minecraftforge.fml.common.SidedProxy not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'clientSide()' in type 'SidedProxy' +Note: Writing plugin metadata to file:/C:/Users/Jesse/Desktop/OTHER/GitHub/FastAsyncWorldEdit/forge/build/classes/main/mcmod.info +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'modid()' in type 'Mod': class file for net.minecraftforge.fml.common.Mod not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'name()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'version()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'acceptableRemoteVersions()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'dependencies()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'acceptedMinecraftVersions()' in type 'Mod' +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'value()' in type 'Instance': class file for net.minecraftforge.fml.common.Mod$Instance not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'serverSide()' in type 'SidedProxy': class file for net.minecraftforge.fml.common.SidedProxy not found +C:\Users\Jesse\.gradle\caches\modules-2\files-2.1\com.sk89q.worldedit\worldedit-forge-mc1.8.9\6.1.1\dffd7e1882eba256eb2132fe315682c1d26522b1\worldedit-forge-mc1.8.9-6.1.1.jar(com/sk89q/worldedit/forge/ForgeWorldEdit.class): warning: Cannot find annotation method 'clientSide()' in type 'SidedProxy' +Note: Some input files use or override a deprecated API. +Note: Recompile with -Xlint:deprecation for details. +Note: Some input files use unchecked or unsafe operations. +Note: Recompile with -Xlint:unchecked for details. +27 warnings + +:forge:processResources UP-TO-DATE +:forge:classes +:forge:jar +:forge:sourceTestJava UP-TO-DATE +:forge:compileTestJava UP-TO-DATE +:forge:processTestResources UP-TO-DATE +:forge:testClasses UP-TO-DATE +:forge:test UP-TO-DATE +:forge:reobfJar +:forge:shadowJar +:forge:reobfShadowJar +:forge:extractRangemapReplacedMain +C:\Users\Jesse\Desktop\OTHER\GitHub\FastAsyncWorldEdit\forge\build\sources\main\java +:forge:retromapReplacedMain +remapping source... +:forge:sourceJar +:forge:assemble +:forge:check UP-TO-DATE +:forge:build + +BUILD SUCCESSFUL + +Total time: 36.523 secs diff --git a/forge/src/main/java/com/boydti/fawe/forge/v1_8/SpongeChunk_1_8.java b/forge/src/main/java/com/boydti/fawe/forge/v1_8/SpongeChunk_1_8.java index 47032911..46b68d64 100644 --- a/forge/src/main/java/com/boydti/fawe/forge/v1_8/SpongeChunk_1_8.java +++ b/forge/src/main/java/com/boydti/fawe/forge/v1_8/SpongeChunk_1_8.java @@ -7,6 +7,7 @@ import com.sk89q.worldedit.world.biome.BaseBiome; import java.util.Arrays; import org.spongepowered.api.Sponge; import org.spongepowered.api.world.Chunk; +import org.spongepowered.api.world.World; public class SpongeChunk_1_8 extends FaweChunk { @@ -29,7 +30,8 @@ public class SpongeChunk_1_8 extends FaweChunk { @Override public Chunk getChunk() { if (this.chunk == null) { - this.chunk = Sponge.getServer().getWorld(getParent().world).get().getChunk(getX(), 0, getZ()).get(); + World world = Sponge.getServer().getWorld(getParent().world).get(); + this.chunk = world.loadChunk(getX(), 0, getZ(), true).get(); } return this.chunk; }
xxhash hashing. This package supports both block hashing via -{@link net.jpountz.xxhash.XXHash32} and streaming hashing via -{@link net.jpountz.xxhash.StreamingXXHash32}. Have a look at -{@link net.jpountz.xxhash.XXHashFactory} to know how to get instances of these -interfaces.
Streaming hashing is a little slower but doesn't require to load the whole -stream into memory.
Sample block usage:
- XXHashFactory factory = XXHashFactory.fastestInstance(); - - byte[] data = "12345345234572".getBytes("UTF-8"); - - XXHash32 hash32 = factory.hash32(); - int seed = 0x9747b28c; // used to initialize the hash value, use whatever - // value you want, but always the same - int hash = hash32.hash(data, 0, data.length, seed); -
Sample streaming usage:
- XXHashFactory factory = XXHashFactory.fastestInstance(); - - byte[] data = "12345345234572".getBytes("UTF-8"); - ByteArrayInputStream in = new ByteArrayInputStream(data); - - int seed = 0x9747b28c; // used to initialize the hash value, use whatever - // value you want, but always the same - StreamingXXHash32 hash32 = factory.newStreamingHash32(seed); - byte[] buf = new byte[8]; // for real-world usage, use a larger buffer, like 8192 bytes - for (;;) { - int read = in.read(buf); - if (read == -1) { - break; - } - hash32.update(buf, 0, read); - } - int hash = hash32.getValue(); -