Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util.io;
  
  import org.jruby.Ruby;
  
  public class OpenFile {
  
      // IO Mode flags
     public static final int READABLE           = 0x00000001;
     public static final int WRITABLE           = 0x00000002;
     public static final int READWRITE          =  | ;
     public static final int BINMODE            = 0x00000004;
     public static final int SYNC               = 0x00000008;
     public static final int WBUF               = 0x00000010; // TTY
     public static final int RBUF               = 0x00000020; // DUPLEX
     public static final int APPEND             = 0x00000040;
     public static final int CREATE             = 0x00000080;
     public static final int WSPLIT             = 0x00000200;
     public static final int WSPLIT_INITIALIZED = 0x00000400;
     public static final int TRUNC              = 0x00000800;
     public static final int TEXTMODE           = 0x00001000;
     public static final int SETENC_BY_BOM      = 0x00100000;
     
     public static final int SYNCWRITE =  | ;
 
     public static interface Finalizer {
 
         public void finalize(Ruby runtimeboolean raise);
     }
     private Stream mainStream;
     private Stream pipeStream;
     private int mode;
     private Process process;
     private int lineNumber = 0;
     private String path;
     private Finalizer finalizer;
 
     public Stream getMainStream() {
         return ;
     }
 
     public Stream getMainStreamSafe() throws BadDescriptorException {
         Stream stream = ;
         if (stream == nullthrow new BadDescriptorException();
         return stream;
     }
 
     public void setMainStream(Stream mainStream) {
         this. = mainStream;
     }
 
     public Stream getPipeStream() {
         return ;
     }
 
     public Stream getPipeStreamSafe() throws BadDescriptorException {
         Stream stream = ;
         if (stream == nullthrow new BadDescriptorException();
         return stream;
     }
 
     public void setPipeStream(Stream pipeStream) {
         this. = pipeStream;
     }
 
     public Stream getWriteStream() {
         return  == null ?  : ;
     }
 
     public Stream getWriteStreamSafe() throws BadDescriptorException {
         Stream stream =  == null ?  : ;
         if (stream == nullthrow new BadDescriptorException();
         return stream;
     }
 
     public int getMode() {
         return ;
     }
     
     public String getModeAsString(Ruby runtime) {
         String modeString = getStringFromMode();
 
         if (modeString == null) {
             throw runtime.newArgumentError("Illegal access modenum " + Integer.toOctalString());
         }
 
         return modeString;
     }
 
     public static String getStringFromMode(int mode) {
         if ((mode & ) != 0) {
             if ((mode & ) != 0) {
                 return "ab+";
             }
             return "ab";
         }
         switch (mode & ) {
         case :
            return "rb";
        case :
            return "wb";
        case :
            if ((mode & ) != 0) {
                return "wb+";
            }
            return "rb+";
        }
        return null;
    }
    public void checkReadable(Ruby runtimethrows IOExceptionBadDescriptorExceptionInvalidValueException {
        checkClosed(runtime);
        if (( & ) == 0) {
            throw runtime.newIOError("not opened for reading");
        }
        if ((( & ) != 0 || ( & ( | )) == ) &&
                !.feof() &&  == null) {
            try {
                // seek to force underlying buffer to flush
                seek(0, .);
            } catch (PipeException p) {
                // ignore unseekable streams for purposes of checking readability
            } catch (IOException ioe) {
                // MRI ignores seek errors, presumably for unseekable files like
                // serial ports (JRUBY-2979), so we shall too.
            }
        }
    }
    public void seek(long offsetint whencethrows IOExceptionInvalidValueExceptionPipeExceptionBadDescriptorException {
        Stream stream = getWriteStreamSafe();
        seekInternal(streamoffsetwhence);
    }
    private void seekInternal(Stream streamlong offsetint whencethrows IOExceptionInvalidValueExceptionPipeExceptionBadDescriptorException {
        flushBeforeSeek(stream);
        stream.lseek(offsetwhence);
    }
    private void flushBeforeSeek(Stream streamthrows BadDescriptorExceptionIOException {
        if (( & ) != 0) {
            fflush(stream);
        }
    }
    public void fflush(Stream streamthrows IOExceptionBadDescriptorException {
        while (true) {
            int n = stream.fflush();
            if (n != -1) {
                break;
            }
        }
         &= ~;
    }
    public void checkWritable(Ruby runtimethrows IOExceptionBadDescriptorExceptionInvalidValueException {
        checkClosed(runtime);
        if (( & ) == 0) {
            throw runtime.newIOError("not opened for writing");
        }
        if (( & ) != 0 && !.feof() &&  == null) {
            try {
                // seek to force read buffer to invalidate
                seek(0, .);
            } catch (PipeException p) {
                // ignore unseekable streams for purposes of checking readability
            } catch (IOException ioe) {
                // MRI ignores seek errors, presumably for unseekable files like
                // serial ports (JRUBY-2979), so we shall too.
            }
        }
        if ( == null) {
             &= ~;
        }
    }
    public void checkClosed(Ruby runtime) {
        if ( == null &&  == null) {
            throw runtime.newIOError("closed stream");
        }
    }
    public boolean isBinmode() {
        return ( & ) != 0;
    }
    
    public boolean isTextMode() {
        return ( & ) != 0;
    }
    
    public void setTextMode() {
         |= ;
        // FIXME: Make stream(s) know about text mode.
    }
    public void clearTextMode() {
         &= ~;
        // FIXME: Make stream(s) know about text mode.
    }
 
    public void setBinmode() {
         |= ;
        if ( != null) {
            .setBinmode();
        }
        if ( != null) {
            .setBinmode();
        }
    }
    public boolean isOpen() {
        return  != null ||  != null;
    }
    public boolean isReadable() {
        return ( & ) != 0;
    }
    public boolean isWritable() {
        return ( & ) != 0;
    }
    public boolean isReadBuffered() {
        return ( & ) != 0;
    }
    public void setReadBuffered() {
         |= ;
    }
    public boolean isWriteBuffered() {
        return ( & ) != 0;
    }
    public void setWriteBuffered() {
         |= ;
    }
    public void setSync(boolean sync) {
        if(sync) {
             =  | ;
        } else {
             =  & ~;
        }
    }
    public boolean isSync() {
        return ( & ) != 0;
    }
    public boolean areBothEOF() throws IOExceptionBadDescriptorException {
        return .feof() && ( != null ? .feof() : true);
    }
    public void setMode(int modes) {
        this. = modes;
    }
    
    public Process getProcess() {
        return ;
    }
    public void setProcess(Process process) {
        this. = process;
    }
    public long getPid() {
        return ShellLauncher.getPidFromProcess();
    }
    public int getLineNumber() {
        return ;
    }
    public void setLineNumber(int lineNumber) {
        this. = lineNumber;
    }
    public String getPath() {
        return ;
    }
    public void setPath(String path) {
        this. = path;
    }
    public boolean isAutoclose() {
        boolean autoclose = true;
        Stream myMainmyPipe;
        if ((myMain = ) != nullautoclose &= myMain.isAutoclose();
        if ((myPipe = ) != nullautoclose &= myPipe.isAutoclose();
        return autoclose;
    }
    public void setAutoclose(boolean autoclose) {
        Stream myMainmyPipe;
        if ((myMain = ) != nullmyMain.setAutoclose(autoclose);
        if ((myPipe = ) != nullmyPipe.setAutoclose(autoclose);
    }
    public Finalizer getFinalizer() {
        return ;
    }
    public void setFinalizer(Finalizer finalizer) {
        this. = finalizer;
    }
    public void cleanup(Ruby runtimeboolean raise) {
        if ( != null) {
            .finalize(runtimeraise);
        } else {
            finalize(runtimeraise);
        }
    }
    public void finalize(Ruby runtimeboolean raise) {
        try {
            ChannelDescriptor pipe = null;
            
            // Recent JDKs shut down streams in the parent when child
            // terminates, so we can't trust that they'll be open for our
            // close. Check for that.
            
            boolean isProcess =  != null;
            synchronized (this) {
                Stream ps = ;
                if (ps != null) {
                    pipe = ps.getDescriptor();
                    try {
                        // Newer JDKs actively close the process streams when
                        // the child exits, so we have to confirm it's still
                        // open to avoid raising an error here when we try to
                        // flush and close the stream.
                        if (isProcess && ps.getChannel().isOpen()
                                || !isProcess) {
                            ps.fflush();
                            ps.fclose();
                        }
                    } finally {
                        // make sure the pipe stream is set to null
                         = null;
                    }
                }
                Stream ms = ;
                if (ms != null) {
                    // TODO: Ruby logic is somewhat more complicated here, see comments after
                    ChannelDescriptor main = ms.getDescriptor();
                    runtime.removeFilenoIntMap(main.getFileno());
                    try {
                        // Newer JDKs actively close the process streams when
                        // the child exits, so we have to confirm it's still
                        // open to avoid raising an error here when we try to
                        // flush and close the stream.
                        if (isProcess) {
                            if (ms.getChannel().isOpen()) {
                                if (pipe == null && isWriteBuffered()) {
                                    ms.fflush();
                                }
                                try {
                                    ms.fclose();
                                } catch (IOException ioe) {
                                    // OpenJDK 7 seems to leave the FileChannel in a state where
                                    // the fd is no longer valid, but the channel is not marked
                                    // as open, so we get IOException: Bad file descriptor here.
                                    if (!ioe.getMessage().equals("Bad file descriptor")) throw ioe;
                                    // If the process is still alive, allow the error to propagate
                                    boolean isAlive = false;
                                    try { .exitValue(); } catch (IllegalThreadStateException itse) { isAlive = true; }
                                    if (isAlivethrow ioe;
                                }
                            }
                        } else {
                            if (pipe == null && isWriteBuffered()) {
                                ms.fflush();
                            }
                            ms.fclose();
                        }
                    } catch (BadDescriptorException bde) {
                        if (main != pipethrow bde;
                    } finally {
                        // make sure the main stream is set to null
                         = null;
                    }
                }
            }
        } catch (IOException ex) {
            if (raise) {
                throw runtime.newIOErrorFromException(ex);
            }
        } catch (BadDescriptorException ex) {
            if (raise) {
                throw runtime.newErrnoEBADFError();
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
New to GrepCode? Check out our FAQ X