Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //
  //  ========================================================================
  //  Copyright (c) 1995-2012 Mort Bay Consulting Pty. Ltd.
  //  ------------------------------------------------------------------------
  //  All rights reserved. This program and the accompanying materials
  //  are made available under the terms of the Eclipse Public License v1.0
  //  and Apache License v2.0 which accompanies this distribution.
  //
  //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //
 
 package org.eclipse.jetty.io;
 
 import java.io.Writer;
 
 
 /* ------------------------------------------------------------ */
A wrapper for the java.io.PrintWriter that re-throws the instances of java.io.IOException thrown by the underlying implementation of java.io.Writer as RuntimeIOException instances.
 
 public class UncheckedPrintWriter extends PrintWriter
 {
     private static final Logger LOG = Log.getLogger(UncheckedPrintWriter.class);
 
     private boolean _autoFlush = false;
     private IOException _ioException;
     private boolean _isClosed = false;
 
     /* ------------------------------------------------------------ */
    
Line separator string. This is the value of the line.separator property at the moment that the stream was created.
 
     private String _lineSeparator;
 
     public UncheckedPrintWriter(Writer out)
     {
         this(out,false);
     }
 
     /* ------------------------------------------------------------ */
    
Create a new PrintWriter.

Parameters:
out A character-output stream
autoFlush A boolean; if true, the println() methods will flush the output buffer
 
     public UncheckedPrintWriter(Writer outboolean autoFlush)
     {
         super(out,autoFlush);
         this. = autoFlush;
         this. = System.getProperty("line.separator");
     }
 
     /* ------------------------------------------------------------ */
    
Create a new PrintWriter, without automatic line flushing, from an existing OutputStream. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will convert characters into bytes using the default character encoding.

Parameters:
out An output stream
See also:
java.io.OutputStreamWriter.java.io.OutputStreamWriter.(java.io.OutputStream)
 
     public UncheckedPrintWriter(OutputStream out)
     {
         this(out,false);
     }
 
     /* ------------------------------------------------------------ */
    
Create a new PrintWriter from an existing OutputStream. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will convert characters into bytes using the default character encoding.

Parameters:
out An output stream
autoFlush A boolean; if true, the println() methods will flush the output buffer
See also:
java.io.OutputStreamWriter.java.io.OutputStreamWriter.(java.io.OutputStream)
    public UncheckedPrintWriter(OutputStream outboolean autoFlush)
    {
        this(new BufferedWriter(new OutputStreamWriter(out)),autoFlush);
    }
    
    
    /* ------------------------------------------------------------ */
    public boolean checkError()
    {
        return !=null || super.checkError();
    }
    
    /* ------------------------------------------------------------ */
    private void setError(Throwable th)
    {
      
        super.setError();
        if (th instanceof IOException)
            =(IOException)th;
        else
        {
            =new IOException(String.valueOf(th));
            .initCause(th);
        }
        .debug(th);
    }
    @Override
    protected void setError()
    {
        setError(new IOException());
    }
    /* ------------------------------------------------------------ */
    
Check to make sure that the stream has not been closed
    private void isOpen() throws IOException
    {       
        if (!=null)
            throw new RuntimeIOException(); 
        
        if ()
            throw new IOException("Stream closed");
    }
    /* ------------------------------------------------------------ */
    
Flush the stream.
    @Override
    public void flush()
    {
        try
        {
            synchronized ()
            {
                isOpen();
                .flush();
            }
        }
        catch (IOException ex)
        {
            setError(ex);
        }
    }
    /* ------------------------------------------------------------ */
    
Close the stream.
    @Override
    public void close()
    {
        try
        {
            synchronized ()
            {
                .close();
                 = true;
            }
        }
        catch (IOException ex)
        {
            setError(ex);
        }
    }
    /* ------------------------------------------------------------ */
    
Write a single character.

Parameters:
c int specifying a character to be written.
    @Override
    public void write(int c)
    {
        try
        {
            synchronized ()
            {
                isOpen();
                .write(c);
            }
        }
        catch (InterruptedIOException x)
        {
            Thread.currentThread().interrupt();
        }
        catch (IOException ex)
        {
            setError(ex);
        }
    }
    /* ------------------------------------------------------------ */
    
Write a portion of an array of characters.

Parameters:
buf Array of characters
off Offset from which to start writing characters
len Number of characters to write
    @Override
    public void write(char buf[], int offint len)
    {
        try
        {
            synchronized ()
            {
                isOpen();
                .write(buf,off,len);
            }
        }
        catch (InterruptedIOException x)
        {
            Thread.currentThread().interrupt();
        }
        catch (IOException ex)
        {
            setError(ex);
        }
    }
    /* ------------------------------------------------------------ */
    
Write an array of characters. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

Parameters:
buf Array of characters to be written
    @Override
    public void write(char buf[])
    { 
        this.write(buf,0,buf.length);
    }
    /* ------------------------------------------------------------ */
    
Write a portion of a string.

Parameters:
s A String
off Offset from which to start writing characters
len Number of characters to write
    @Override
    public void write(String sint offint len)
    {
        try
        {
            synchronized ()
            {
                isOpen();
                .write(s,off,len);
            }
        }
        catch (InterruptedIOException x)
        {
            Thread.currentThread().interrupt();
        }
        catch (IOException ex)
        {
            setError(ex);
        }
    }
    /* ------------------------------------------------------------ */
    
Write a string. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

Parameters:
s String to be written
    @Override
    public void write(String s)
    {
        this.write(s,0,s.length());
    }
    private void newLine()
    {
        try
        {
            synchronized ()
            {
                isOpen();
                .write();
                if ()
                    .flush();
            }
        }
        catch (InterruptedIOException x)
        {
            Thread.currentThread().interrupt();
        }
        catch (IOException ex)
        {
            setError(ex);
        }
    }
    /* ------------------------------------------------------------ */
    
Print a boolean value. The string produced by java.lang.String.valueOf(boolean) is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
b The boolean to be printed
    @Override
    public void print(boolean b)
    {
        this.write(b?"true":"false");
    }
    /* ------------------------------------------------------------ */
    
Print a character. The character is translated into one or more bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
c The char to be printed
    @Override
    public void print(char c)
    {
        this.write(c);
    }
    /* ------------------------------------------------------------ */
    
Print an integer. The string produced by java.lang.String.valueOf(int) is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
i The int to be printed
See also:
java.lang.Integer.toString(int)
    @Override
    public void print(int i)
    {
        this.write(String.valueOf(i));
    }
    /* ------------------------------------------------------------ */
    
Print a long integer. The string produced by java.lang.String.valueOf(long) is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
l The long to be printed
See also:
java.lang.Long.toString(long)
    @Override
    public void print(long l)
    {
        this.write(String.valueOf(l));
    }
    /* ------------------------------------------------------------ */
    
Print a floating-point number. The string produced by java.lang.String.valueOf(float) is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
f The float to be printed
See also:
java.lang.Float.toString(float)
    @Override
    public void print(float f)
    {
        this.write(String.valueOf(f));
    }
    /* ------------------------------------------------------------ */
    
Print a double-precision floating-point number. The string produced by java.lang.String.valueOf(double) is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
d The double to be printed
See also:
java.lang.Double.toString(double)
    @Override
    public void print(double d)
    {
        this.write(String.valueOf(d));
    }
    /* ------------------------------------------------------------ */
    
Print an array of characters. The characters are converted into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
s The array of chars to be printed
Throws:
java.lang.NullPointerException If s is null
    @Override
    public void print(char s[])
    {
        this.write(s);
    }
    /* ------------------------------------------------------------ */
    
Print a string. If the argument is null then the string "null" is printed. Otherwise, the string's characters are converted into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
s The String to be printed
    @Override
    public void print(String s)
    {
        if (s == null)
        {
            s = "null";
        }
        this.write(s);
    }
    /* ------------------------------------------------------------ */
    
Print an object. The string produced by the java.lang.String.valueOf(java.lang.Object) method is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the write(int) method.

Parameters:
obj The Object to be printed
See also:
java.lang.Object.toString()
    @Override
    public void print(Object obj)
    {
        this.write(String.valueOf(obj));
    }
    /* ------------------------------------------------------------ */
    
Terminate the current line by writing the line separator string. The line separator string is defined by the system property line.separator, and is not necessarily a single newline character ('\n').
    @Override
    public void println()
    {
        this.newLine();
    }
    /* ------------------------------------------------------------ */
    
Print a boolean value and then terminate the line. This method behaves as though it invokes print(boolean) and then println().

Parameters:
x the boolean value to be printed
    @Override
    public void println(boolean x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print a character and then terminate the line. This method behaves as though it invokes print(char) and then println().

Parameters:
x the char value to be printed
    @Override
    public void println(char x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print an integer and then terminate the line. This method behaves as though it invokes print(int) and then println().

Parameters:
x the int value to be printed
    @Override
    public void println(int x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print a long integer and then terminate the line. This method behaves as though it invokes print(long) and then println().

Parameters:
x the long value to be printed
    @Override
    public void println(long x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print a floating-point number and then terminate the line. This method behaves as though it invokes print(float) and then println().

Parameters:
x the float value to be printed
    @Override
    public void println(float x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print a double-precision floating-point number and then terminate the line. This method behaves as though it invokes print(double) and then println().

Parameters:
x the double value to be printed
    /* ------------------------------------------------------------ */
    @Override
    public void println(double x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print an array of characters and then terminate the line. This method behaves as though it invokes print(char[]) and then println().

Parameters:
x the array of char values to be printed
    @Override
    public void println(char x[])
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print a String and then terminate the line. This method behaves as though it invokes print(java.lang.String) and then println().

Parameters:
x the String value to be printed
    @Override
    public void println(String x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
    /* ------------------------------------------------------------ */
    
Print an Object and then terminate the line. This method behaves as though it invokes print(java.lang.Object) and then println().

Parameters:
x the Object value to be printed
    @Override
    public void println(Object x)
    {
        synchronized ()
        {
            this.print(x);
            this.println();
        }
    }
New to GrepCode? Check out our FAQ X