ZstdEncoder Class — netty Architecture

Source Code

codec-compression/src/main/java/io/netty/handler/codec/compression/ZstdEncoder.java lines 37–201

public final class ZstdEncoder extends MessageToByteEncoder<ByteBuf> {
    // Don't use static here as we want to still allow to load the classes.
    {
        try {
            io.netty.handler.codec.compression.Zstd.ensureAvailability();
        } catch (Throwable throwable) {
            throw new ExceptionInInitializerError(throwable);
        }
    }
    private final int blockSize;
    private final int compressionLevel;
    private final int maxEncodeSize;
    private ByteBuf buffer;

    /**
     * Creates a new Zstd encoder.
     *
     * Please note that if you use the default constructor, the default BLOCK_SIZE and MAX_BLOCK_SIZE
     * will be used. If you want to specify BLOCK_SIZE and MAX_BLOCK_SIZE yourself,
     * please use {@link ZstdEncoder(int,int)} constructor
     */
    public ZstdEncoder() {
        this(DEFAULT_COMPRESSION_LEVEL, DEFAULT_BLOCK_SIZE, DEFAULT_MAX_ENCODE_SIZE);
    }

    /**
     * Creates a new Zstd encoder.
     *  @param  compressionLevel
     *            specifies the level of the compression
     */
    public ZstdEncoder(int compressionLevel) {
        this(compressionLevel, DEFAULT_BLOCK_SIZE, DEFAULT_MAX_ENCODE_SIZE);
    }

    /**
     * Creates a new Zstd encoder.
     *  @param  blockSize
     *            is used to calculate the compressionLevel
     *  @param  maxEncodeSize
     *            specifies the size of the largest compressed object
     */
    public ZstdEncoder(int blockSize, int maxEncodeSize) {
        this(DEFAULT_COMPRESSION_LEVEL, blockSize, maxEncodeSize);
    }

    /**
     * @param  blockSize
     *           is used to calculate the compressionLevel
     * @param  maxEncodeSize
     *           specifies the size of the largest compressed object
     * @param  compressionLevel
     *           specifies the level of the compression
     */
    public ZstdEncoder(int compressionLevel, int blockSize, int maxEncodeSize) {
        super(ByteBuf.class, true);
        this.compressionLevel = ObjectUtil.checkInRange(compressionLevel,
                MIN_COMPRESSION_LEVEL, MAX_COMPRESSION_LEVEL, "compressionLevel");
        this.blockSize = ObjectUtil.checkPositive(blockSize, "blockSize");
        this.maxEncodeSize = ObjectUtil.checkPositive(maxEncodeSize, "maxEncodeSize");
    }

    @Override
    protected ByteBuf allocateBuffer(ChannelHandlerContext ctx, ByteBuf msg, boolean preferDirect) {
        if (buffer == null) {
            throw new IllegalStateException("not added to a pipeline," +
                    "or has been removed,buffer is null");
        }

        int remaining = msg.readableBytes() + buffer.readableBytes();

        // quick overflow check
        if (remaining < 0) {
            throw new EncoderException("too much data to allocate a buffer for compression");
        }

        long bufferSize = 0;
        while (remaining > 0) {
            int curSize = Math.min(blockSize, remaining);
            remaining -= curSize;
            // calculate the max compressed size with Zstd.compressBound since
            // it returns the maximum size of the compressed data