Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   */
  package org.jruby.ext.zlib;
  
  import org.jruby.Ruby;
 import static org.jruby.runtime.Visibility.PRIVATE;
 
  @JRubyClass(name = "Zlib::Inflate", parent = "Zlib::ZStream")
 public class JZlibInflate extends ZStream {
 
     public static final int BASE_SIZE = 100;
     private int windowBits;
     private byte[] collected;
     private int collectedIdx;
     private ByteList input;
     private com.jcraft.jzlib.Inflater flater = null;
     protected static final ObjectAllocator INFLATE_ALLOCATOR = new ObjectAllocator() {
 
         public IRubyObject allocate(Ruby runtimeRubyClass klass) {
             return new JZlibInflate(runtimeklass);
         }
     };
 
     public JZlibInflate(Ruby runtimeRubyClass type) {
         super(runtimetype);
     }
 
     @JRubyMethod(name = "inflate", required = 1, meta = true)
     public static IRubyObject s_inflate(ThreadContext contextIRubyObject recvIRubyObject string) {
         RubyClass klass = (RubyClassrecv;
         JZlibInflate inflate = (JZlibInflateklass.allocate();
         inflate.init(.);
 
         IRubyObject result;
         try {
             inflate.append(string.convertToString().getByteList());
         } finally {
             result = inflate.finish(context);
             inflate.close();
         }
         return result;
     }
 
     @JRubyMethod(name = "initialize", optional = 1, visibility = )
     public IRubyObject _initialize(IRubyObject[] args) {
          = .;
 
         if (args.length > 0 && !args[0].isNil()) {
              = RubyNumeric.fix2int(args[0]);
             checkWindowBits(getRuntime(), true);
         }
 
         init();
         return this;
     }
 
     private void init(int windowBits) {
          = new com.jcraft.jzlib.Inflater();
         .init(windowBits);
          = new byte[];
          = 0;
          = new ByteList();
     }
 
     @Override
     @JRubyMethod(name = "flush_next_out")
     public IRubyObject flush_next_out(ThreadContext context) {
         return flushOutput(context.getRuntime());
     }
 
     private RubyString flushOutput(Ruby runtime) {
         if ( > 0) {
             RubyString res = RubyString.newString(runtime, 0, );
              = 0;
             .setOutput();
             return res;
         }
         return RubyString.newEmptyString(runtime);
     }
 
     @JRubyMethod(name = "<<", required = 1)
     public IRubyObject append(ThreadContext contextIRubyObject arg) {
         checkClosed();
         if (arg.isNil()) {
             run(true);
         } else {
            append(arg.convertToString().getByteList());
        }
        return this;
    }
    public void append(ByteList obj) {
        if (!internalFinished()) {
            .setInput(obj.bytes(), true);
        } else {
            .append(obj);
        }
        run(false);
    }
    @JRubyMethod(name = "sync_point?")
    public IRubyObject sync_point_p() {
        return sync_point();
    }
    public IRubyObject sync_point() {
        int ret = .syncPoint();
        switch (ret) {
            case 1:
                return getRuntime().getTrue();
            case ....:
                throw RubyZlib.newStreamError(getRuntime(), "stream error");
            default:
                return getRuntime().getFalse();
        }
    }
    @JRubyMethod(name = "set_dictionary", required = 1)
    public IRubyObject set_dictionary(ThreadContext contextIRubyObject arg) {
        try {
            return set_dictionary(arg);
        } catch (IllegalArgumentException iae) {
            throw RubyZlib.newStreamError(context.getRuntime(), "stream error: " + iae.getMessage());
        }
    }
    private IRubyObject set_dictionary(IRubyObject str) {
        byte[] tmp = str.convertToString().getBytes();
        int ret = .setDictionary(tmptmp.length);
        switch (ret) {
            case ....:
                throw RubyZlib.newStreamError(getRuntime(), "stream error");
            case ....:
                throw RubyZlib.newDataError(getRuntime(), "wrong dictionary");
            default:
        }
        run(false);
        return str;
    }
    @JRubyMethod(name = "inflate", required = 1)
    public IRubyObject inflate(ThreadContext contextIRubyObject string) {
        ByteList data = null;
        if (!string.isNil()) {
            data = string.convertToString().getByteList();
        }
        return inflate(contextdata);
    }
    public IRubyObject inflate(ThreadContext contextByteList str) {
        if (null == str) {
            return internalFinish();
        } else {
            append(str);
            return flushOutput(context.getRuntime());
        }
    }
    @JRubyMethod(name = "sync", required = 1)
    public IRubyObject sync(ThreadContext contextIRubyObject string) {
        if (. > 0) {
            switch (.sync()) {
                case ....:
                    .setInput(string.convertToString().getByteList().bytes(),
                            true);
                    return getRuntime().getTrue();
                case ....:
                    break;
                default:
                    throw RubyZlib.newStreamError(getRuntime(), "stream error");
            }
        }
        if (string.convertToString().getByteList().length() <= 0) {
            return getRuntime().getFalse();
        }
        .setInput(string.convertToString().getByteList().bytes(), true);
        switch (.sync()) {
            case ....:
                return getRuntime().getTrue();
            case ....:
                return getRuntime().getFalse();
            default:
                throw RubyZlib.newStreamError(getRuntime(), "stream error");
        }
    }
    private void run(boolean finish) {
        int resultLength = -1;
        Ruby runtime = getRuntime();
        while (!internalFinished() && resultLength != 0) {
            // MRI behavior
            boolean needsInput = . < 0;
            if (finish && needsInput) {
                throw RubyZlib.newBufError(runtime"buffer error");
            }
            int ret = .inflate(....);
            resultLength = . - ;
             = .;
            switch (ret) {
                case ....:
                    /*
                     * resultLength = flater.next_out_index; if(resultLength>0){
                     * // error has been occurred, // but some data has been
                     * inflated successfully. collected.append(outp, 0,
                     * resultLength); }
                     */
                    throw RubyZlib.newDataError(runtime.getMessage());
                case ....:
                    throw RubyZlib.newDictError(runtime"need dictionary");
                case ....:
                    if (. > 0) {
                        // MRI behavior: pass-through
                        .append(.,
                                ..);
                        .setInput("".getBytes());
                    }
                case ....:
                    resultLength = .;
                    break;
                default:
                    resultLength = 0;
            }
            if (. ==  && !internalFinished()) {
                byte[] tmp = new byte[. * 3];
                System.arraycopy(, 0, tmp, 0, .);
                 = tmp;
            }
        }
        if (finish) {
            if (!internalFinished()) {
                int err = .inflate(....);
                if (err != ....) {
                    throw RubyZlib.newBufError(getRuntime(), "buffer error");
                }
            }
        }
    }
    @Override
    protected int internalTotalIn() {
        return (int.;
    }
    @Override
    protected int internalTotalOut() {
        return (int.;
    }
    @Override
    protected boolean internalStreamEndP() {
        return .finished();
    }
    @Override
    protected void internalReset() {
        init();
    }
    @Override
    protected boolean internalFinished() {
        return .finished();
    }
    @Override
    protected long internalAdler() {
        return .getAdler();
    }
    @Override
    protected IRubyObject internalFinish() {
        run(true);
        // MRI behavior: in finished mode, we work as pass-through
        if (internalFinished()) {
            if (.getRealSize() > 0) {
                if (. -  < .length()) {
                    byte[] tmp = new byte[. + .length()];
                    System.arraycopy(, 0, tmp, 0, );
                     = tmp;
                }
                System.arraycopy(.getUnsafeBytes(), .begin(), .length());
                 += .length();
                resetBuffer();
            }
        }
        return flushOutput(getRuntime());
    }
    @Override
    protected void internalClose() {
        .end();
    }
    @Override
    public IRubyObject avail_in() {
        return getRuntime().newFixnum(.);
    }
    private static void resetBuffer(ByteList l) {
        l.setBegin(0);
        l.setRealSize(0);
        l.invalidate();
    }
New to GrepCode? Check out our FAQ X