Java LZ4Exception类代码示例

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public void compress(ByteBuffer input, ByteBuffer output) throws IOException
{
    int len = input.remaining();
    output.put((byte) len);
    output.put((byte) (len >>> 8));
    output.put((byte) (len >>> 16));
    output.put((byte) (len >>> 24));

    try
    {
        compressor.compress(input, output);
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public int uncompress(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset) throws IOException
{
    final int decompressedLength =
            (input[inputOffset] & 0xFF)
            | ((input[inputOffset + 1] & 0xFF) << 8)
            | ((input[inputOffset + 2] & 0xFF) << 16)
            | ((input[inputOffset + 3] & 0xFF) << 24);

    final int compressedLength;
    try
    {
        compressedLength = decompressor.decompress(input, inputOffset + INTEGER_BYTES,
                                                   output, outputOffset, decompressedLength);
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }

    if (compressedLength != inputLength - INTEGER_BYTES)
    {
        throw new IOException("Compressed lengths mismatch");
    }

    return decompressedLength;
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
@Override
public byte[] decompress(byte[] data, int offset, int length, OpStatsLogger decompressionStat) {
    Preconditions.checkNotNull(data);
    Preconditions.checkArgument(offset >= 0 && offset < data.length);
    Preconditions.checkArgument(length >= 0);
    Preconditions.checkNotNull(decompressionStat);

    Stopwatch watch = Stopwatch.createStarted();
    // Assume that we have a compression ratio of 1/3.
    int outLength = length * 3;
    while (true) {
        try {
            byte[] decompressed = safeDecompressor.decompress(data, offset, length, outLength);
            decompressionStat.registerSuccessfulEvent(watch.elapsed(TimeUnit.MICROSECONDS));
            return decompressed;
        } catch (LZ4Exception e) {
            outLength *= 2;
        }
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public int compress(byte[] input, int inputOffset, int inputLength, WrappedArray output, int outputOffset) throws IOException
{
    final byte[] dest = output.buffer;
    dest[outputOffset] = (byte) inputLength;
    dest[outputOffset + 1] = (byte) (inputLength >>> 8);
    dest[outputOffset + 2] = (byte) (inputLength >>> 16);
    dest[outputOffset + 3] = (byte) (inputLength >>> 24);
    final int maxCompressedLength = compressor.maxCompressedLength(inputLength);
    try
    {
        return INTEGER_BYTES + compressor.compress(input, inputOffset, inputLength,
                                                   dest, outputOffset + INTEGER_BYTES, maxCompressedLength);
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public int uncompress(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset) throws IOException
{
    final int decompressedLength =
            (input[inputOffset] & 0xFF)
            | ((input[inputOffset + 1] & 0xFF) << 8)
            | ((input[inputOffset + 2] & 0xFF) << 16)
            | ((input[inputOffset + 3] & 0xFF) << 24);
    final int compressedLength;
    try
    {
        compressedLength = decompressor.decompress(input, inputOffset + INTEGER_BYTES,
                                                   output, outputOffset, decompressedLength);
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }

    if (compressedLength != inputLength - INTEGER_BYTES)
    {
        throw new IOException("Compressed lengths mismatch");
    }

    return decompressedLength;
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public Frame compress(Frame frame) throws IOException
{
    byte[] input = CBUtil.readRawBytes(frame.body);

    int maxCompressedLength = compressor.maxCompressedLength(input.length);
    byte[] output = new byte[INTEGER_BYTES + maxCompressedLength];

    output[0] = (byte) (input.length >>> 24);
    output[1] = (byte) (input.length >>> 16);
    output[2] = (byte) (input.length >>>  8);
    output[3] = (byte) (input.length);

    try
    {
        int written = compressor.compress(input, 0, input.length, output, INTEGER_BYTES, maxCompressedLength);
        return frame.with(ChannelBuffers.wrappedBuffer(output, 0, INTEGER_BYTES + written));
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public Frame decompress(Frame frame) throws IOException
{
    byte[] input = CBUtil.readRawBytes(frame.body);

    int uncompressedLength = ((input[0] & 0xFF) << 24)
                           | ((input[1] & 0xFF) << 16)
                           | ((input[2] & 0xFF) <<  8)
                           | ((input[3] & 0xFF));

    byte[] output = new byte[uncompressedLength];

    try
    {
        int read = decompressor.decompress(input, INTEGER_BYTES, output, 0, uncompressedLength);
        if (read != input.length - INTEGER_BYTES)
            throw new IOException("Compressed lengths mismatch");

        return frame.with(ChannelBuffers.wrappedBuffer(output));
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public Frame compress(Frame frame) throws IOException
{
    byte[] input = CBUtil.readRawBytes(frame.body);

    int maxCompressedLength = compressor.maxCompressedLength(input.length);
    byte[] output = new byte[INTEGER_BYTES + maxCompressedLength];

    output[0] = (byte) (input.length >>> 24);
    output[1] = (byte) (input.length >>> 16);
    output[2] = (byte) (input.length >>>  8);
    output[3] = (byte) (input.length);

    try
    {
        int written = compressor.compress(input, 0, input.length, output, INTEGER_BYTES, maxCompressedLength);
        return frame.with(Unpooled.wrappedBuffer(output, 0, INTEGER_BYTES + written));
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public Frame decompress(Frame frame) throws IOException
{
    byte[] input = CBUtil.readRawBytes(frame.body);

    int uncompressedLength = ((input[0] & 0xFF) << 24)
                           | ((input[1] & 0xFF) << 16)
                           | ((input[2] & 0xFF) <<  8)
                           | ((input[3] & 0xFF));

    byte[] output = new byte[uncompressedLength];

    try
    {
        int read = decompressor.decompress(input, INTEGER_BYTES, output, 0, uncompressedLength);
        if (read != input.length - INTEGER_BYTES)
            throw new IOException("Compressed lengths mismatch");

        return frame.with(Unpooled.wrappedBuffer(output));
    }
    catch (LZ4Exception e)
    {
        throw new IOException(e);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
private static ByteBuf readBody(LZ4FastDecompressor decompressor, StreamingXXHash32 checksum, Header header,
                                byte[] bytes, int off) throws ParseException {
	ByteBuf outputBuf = ByteBufPool.allocate(header.originalLen);
	outputBuf.writePosition(header.originalLen);
	switch (header.compressionMethod) {
		case COMPRESSION_METHOD_RAW:
			System.arraycopy(bytes, off, outputBuf.array(), 0, header.originalLen);
			break;
		case COMPRESSION_METHOD_LZ4:
			try {
				int compressedLen2 = decompressor.decompress(bytes, off, outputBuf.array(), 0, header.originalLen);
				if (header.compressedLen != compressedLen2) {
					throw new ParseException("Stream is corrupted");
				}
			} catch (LZ4Exception e) {
				throw new ParseException("Stream is corrupted", e);
			}
			break;
		default:
			throw new AssertionError();
	}
	checksum.reset();
	checksum.update(outputBuf.array(), 0, header.originalLen);
	if (checksum.getValue() != header.check) {
		throw new ParseException("Stream is corrupted");
	}
	return outputBuf;
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
public static byte[] decompress(byte[] data) {
    long decompressedLength = unsigned(concatenateBytes(data[0], data[1], data[2], data[3]));
    if (decompressedLength > MAX_BUFFER_LENGTH) {
        throw new DecompressedDataTooLarge();
    }
    try {
        return decompressor.decompress(data, 4, (int)decompressedLength);
    } catch(LZ4Exception exception) {
        throw new InvalidLZ4Data(exception);
    }
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
@Test
public void compress_and_decompressSafe_less_decompressLength() {
    byte[] compressed = Lz4CompressUtils.compress(ORIGINAL_DATA_BYTES);

    expectedException.expect(LZ4Exception.class);
    Lz4CompressUtils.decompressSafe(compressed, ORIGINAL_DATA_BYTES.length - 100);
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
@Test
public void decompressFast_less_exactDecompressedSize() {
    byte[] compressed = Lz4CompressUtils.compress(ORIGINAL_DATA_BYTES);

    expectedException.expect(LZ4Exception.class);
    Lz4CompressUtils.decompressFast(compressed, ORIGINAL_DATA_BYTES.length - 100);
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
@Test
public void decompressFast_over_exactDecompressedSize() {
    byte[] compressed = Lz4CompressUtils.compress(ORIGINAL_DATA_BYTES);

    expectedException.expect(LZ4Exception.class);
    Lz4CompressUtils.decompressFast(compressed, ORIGINAL_DATA_BYTES.length + 100);
}
 

import net.jpountz.lz4.LZ4Exception; //导入依赖的package包/类
/**
 * Decompresses (if necessary) buffered data, optionally computes and validates a XXHash32 checksum, and writes the
 * result to a buffer.
 *
 * @throws IOException
 */
private void readBlock() throws IOException {
    if (in.remaining() < 4) {
        throw new IOException(PREMATURE_EOS);
    }

    int blockSize = in.getInt();
    boolean compressed = (blockSize & LZ4_FRAME_INCOMPRESSIBLE_MASK) == 0;
    blockSize &= ~LZ4_FRAME_INCOMPRESSIBLE_MASK;

    // Check for EndMark
    if (blockSize == 0) {
        finished = true;
        if (flg.isContentChecksumSet())
            in.getInt(); // TODO: verify this content checksum
        return;
    } else if (blockSize > maxBlockSize) {
        throw new IOException(String.format("Block size %s exceeded max: %s", blockSize, maxBlockSize));
    }

    if (in.remaining() < blockSize) {
        throw new IOException(PREMATURE_EOS);
    }

    if (compressed) {
        try {
            // workaround for https://github.com/lz4/lz4-java/pull/65
            final int bufferSize;
            if (in.hasArray()) {
                bufferSize = DECOMPRESSOR.decompress(
                    in.array(),
                    in.position() + in.arrayOffset(),
                    blockSize,
                    decompressionBuffer.array(),
                    0,
                    maxBlockSize
                );
            } else {
                // decompressionBuffer has zero arrayOffset, so we don't need to worry about
                // https://github.com/lz4/lz4-java/pull/65
                bufferSize = DECOMPRESSOR.decompress(in, in.position(), blockSize, decompressionBuffer, 0, maxBlockSize);
            }
            decompressionBuffer.position(0);
            decompressionBuffer.limit(bufferSize);
            decompressedBuffer = decompressionBuffer;
        } catch (LZ4Exception e) {
            throw new IOException(e);
        }
    } else {
        decompressedBuffer = in.slice();
        decompressedBuffer.limit(blockSize);
    }

    // verify checksum
    if (flg.isBlockChecksumSet()) {
        // workaround for https://github.com/lz4/lz4-java/pull/65
        int hash = in.hasArray() ?
                   CHECKSUM.hash(in.array(), in.arrayOffset() + in.position(), blockSize, 0) :
                   CHECKSUM.hash(in, in.position(), blockSize, 0);
        in.position(in.position() + blockSize);
        if (hash != in.getInt()) {
            throw new IOException(BLOCK_HASH_MISMATCH);
        }
    } else {
        in.position(in.position() + blockSize);
    }
}