changeset 882:d850a5e6ff15

remove UncheckedPrintWriter
author Franklin Schmidt <fschmidt@gmail.com>
date Tue, 04 Oct 2016 16:12:50 -0600
parents 31e803481e33
children 8c494fcd3d34
files src/org/eclipse/jetty/io/UncheckedPrintWriter.java src/org/eclipse/jetty/server/AbstractHttpConnection.java src/org/eclipse/jetty/server/Server.java
diffstat 3 files changed, 12 insertions(+), 712 deletions(-) [+]
line wrap: on
line diff
diff -r 31e803481e33 -r d850a5e6ff15 src/org/eclipse/jetty/io/UncheckedPrintWriter.java
--- a/src/org/eclipse/jetty/io/UncheckedPrintWriter.java	Tue Oct 04 16:04:32 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,682 +0,0 @@
-//
-//  ========================================================================
-//  Copyright (c) 1995-2014 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.BufferedWriter;
-import java.io.IOException;
-import java.io.InterruptedIOException;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.Writer;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/* ------------------------------------------------------------ */
-/**
- * A wrapper for the {@link java.io.PrintWriter} that re-throws the instances of
- * {@link java.io.IOException} thrown by the underlying implementation of
- * {@link java.io.Writer} as {@link RuntimeIOException} instances.
- */
-public class UncheckedPrintWriter extends PrintWriter
-{
-    private static final Logger LOG = LoggerFactory.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.
-     * 
-     * @param out
-     *            A character-output stream
-     * @param autoFlush
-     *            A boolean; if true, the println() methods will flush the
-     *            output buffer
-     */
-    public UncheckedPrintWriter(Writer out, boolean autoFlush)
-    {
-        super(out,autoFlush);
-        this._autoFlush = autoFlush;
-        this._lineSeparator = 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.
-     * 
-     * @param out
-     *            An output stream
-     * 
-     * @see java.io.OutputStreamWriter#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.
-     * 
-     * @param out
-     *            An output stream
-     * @param autoFlush
-     *            A boolean; if true, the println() methods will flush the
-     *            output buffer
-     * 
-     * @see java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
-     */
-    public UncheckedPrintWriter(OutputStream out, boolean autoFlush)
-    {
-        this(new BufferedWriter(new OutputStreamWriter(out)),autoFlush);
-    }
-    
-    
-    /* ------------------------------------------------------------ */
-    public boolean checkError()
-    {
-        return _ioException!=null || super.checkError();
-    }
-    
-    /* ------------------------------------------------------------ */
-    private void setError(Throwable th)
-    {
-      
-        super.setError();
-
-        if (th instanceof IOException)
-            _ioException=(IOException)th;
-        else
-        {
-            _ioException=new IOException(String.valueOf(th));
-            _ioException.initCause(th);
-        }
-
-        LOG.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 (_ioException!=null)
-            throw new RuntimeIOException(_ioException); 
-        
-        if (_isClosed)
-            throw new IOException("Stream closed");
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Flush the stream.
-     */
-    @Override
-    public void flush()
-    {
-        try
-        {
-            synchronized (lock)
-            {
-                isOpen();
-                out.flush();
-            }
-        }
-        catch (IOException ex)
-        {
-            setError(ex);
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Close the stream.
-     */
-    @Override
-    public void close()
-    {
-        try
-        {
-            synchronized (lock)
-            {
-                out.close();
-                _isClosed = true;
-            }
-        }
-        catch (IOException ex)
-        {
-            setError(ex);
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Write a single character.
-     * 
-     * @param c
-     *            int specifying a character to be written.
-     */
-    @Override
-    public void write(int c)
-    {
-        try
-        {
-            synchronized (lock)
-            {
-                isOpen();
-                out.write(c);
-            }
-        }
-        catch (InterruptedIOException x)
-        {
-            Thread.currentThread().interrupt();
-        }
-        catch (IOException ex)
-        {
-            setError(ex);
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Write a portion of an array of characters.
-     * 
-     * @param buf
-     *            Array of characters
-     * @param off
-     *            Offset from which to start writing characters
-     * @param len
-     *            Number of characters to write
-     */
-    @Override
-    public void write(char buf[], int off, int len)
-    {
-        try
-        {
-            synchronized (lock)
-            {
-                isOpen();
-                out.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.
-     * 
-     * @param 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.
-     * 
-     * @param s
-     *            A String
-     * @param off
-     *            Offset from which to start writing characters
-     * @param len
-     *            Number of characters to write
-     */
-    @Override
-    public void write(String s, int off, int len)
-    {
-        try
-        {
-            synchronized (lock)
-            {
-                isOpen();
-                out.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.
-     * 
-     * @param s
-     *            String to be written
-     */
-    @Override
-    public void write(String s)
-    {
-        this.write(s,0,s.length());
-    }
-
-    private void newLine()
-    {
-        try
-        {
-            synchronized (lock)
-            {
-                isOpen();
-                out.write(_lineSeparator);
-                if (_autoFlush)
-                    out.flush();
-            }
-        }
-        catch (InterruptedIOException x)
-        {
-            Thread.currentThread().interrupt();
-        }
-        catch (IOException ex)
-        {
-            setError(ex);
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a boolean value. The string produced by <code>{@link
-     * java.lang.String#valueOf(boolean)}</code> is translated into bytes
-     * according to the platform's default character encoding, and these bytes
-     * are written in exactly the manner of the <code>{@link
-     * #write(int)}</code> method.
-     * 
-     * @param b
-     *            The <code>boolean</code> 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 <code>{@link
-     * #write(int)}</code> method.
-     * 
-     * @param c
-     *            The <code>char</code> to be printed
-     */
-    @Override
-    public void print(char c)
-    {
-        this.write(c);
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print an integer. The string produced by <code>{@link
-     * java.lang.String#valueOf(int)}</code> is translated into bytes according
-     * to the platform's default character encoding, and these bytes are written
-     * in exactly the manner of the <code>{@link #write(int)}</code> method.
-     * 
-     * @param i
-     *            The <code>int</code> to be printed
-     * @see java.lang.Integer#toString(int)
-     */
-    @Override
-    public void print(int i)
-    {
-        this.write(String.valueOf(i));
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a long integer. The string produced by <code>{@link
-     * java.lang.String#valueOf(long)}</code> is translated into bytes according
-     * to the platform's default character encoding, and these bytes are written
-     * in exactly the manner of the <code>{@link #write(int)}</code> method.
-     * 
-     * @param l
-     *            The <code>long</code> to be printed
-     * @see 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 <code>{@link
-     * java.lang.String#valueOf(float)}</code> is translated into bytes
-     * according to the platform's default character encoding, and these bytes
-     * are written in exactly the manner of the <code>{@link #write(int)}</code>
-     * method.
-     * 
-     * @param f
-     *            The <code>float</code> to be printed
-     * @see 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
-     * <code>{@link java.lang.String#valueOf(double)}</code> is translated into
-     * bytes according to the platform's default character encoding, and these
-     * bytes are written in exactly the manner of the <code>{@link
-     * #write(int)}</code> method.
-     * 
-     * @param d
-     *            The <code>double</code> to be printed
-     * @see 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 <code>{@link #write(int)}</code>
-     * method.
-     * 
-     * @param s
-     *            The array of chars to be printed
-     * 
-     * @throws NullPointerException
-     *             If <code>s</code> is <code>null</code>
-     */
-    @Override
-    public void print(char s[])
-    {
-        this.write(s);
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a string. If the argument is <code>null</code> then the string
-     * <code>"null"</code> 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
-     * <code>{@link #write(int)}</code> method.
-     * 
-     * @param s
-     *            The <code>String</code> 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 <code>{@link
-     * java.lang.String#valueOf(Object)}</code> method is translated into bytes
-     * according to the platform's default character encoding, and these bytes
-     * are written in exactly the manner of the <code>{@link #write(int)}</code>
-     * method.
-     * 
-     * @param obj
-     *            The <code>Object</code> to be printed
-     * @see 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
-     * <code>line.separator</code>, and is not necessarily a single newline
-     * character (<code>'\n'</code>).
-     */
-    @Override
-    public void println()
-    {
-        this.newLine();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a boolean value and then terminate the line. This method behaves as
-     * though it invokes <code>{@link #print(boolean)}</code> and then
-     * <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the <code>boolean</code> value to be printed
-     */
-    @Override
-    public void println(boolean x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a character and then terminate the line. This method behaves as
-     * though it invokes <code>{@link #print(char)}</code> and then <code>{@link
-     * #println()}</code>.
-     * 
-     * @param x
-     *            the <code>char</code> value to be printed
-     */
-    @Override
-    public void println(char x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print an integer and then terminate the line. This method behaves as
-     * though it invokes <code>{@link #print(int)}</code> and then <code>{@link
-     * #println()}</code>.
-     * 
-     * @param x
-     *            the <code>int</code> value to be printed
-     */
-    @Override
-    public void println(int x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a long integer and then terminate the line. This method behaves as
-     * though it invokes <code>{@link #print(long)}</code> and then
-     * <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the <code>long</code> value to be printed
-     */
-    @Override
-    public void println(long x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a floating-point number and then terminate the line. This method
-     * behaves as though it invokes <code>{@link #print(float)}</code> and then
-     * <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the <code>float</code> value to be printed
-     */
-    @Override
-    public void println(float x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a double-precision floating-point number and then terminate the
-     * line. This method behaves as though it invokes <code>{@link
-     * #print(double)}</code> and then <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the <code>double</code> value to be printed
-     */
-    /* ------------------------------------------------------------ */
-    @Override
-    public void println(double x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print an array of characters and then terminate the line. This method
-     * behaves as though it invokes <code>{@link #print(char[])}</code> and then
-     * <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the array of <code>char</code> values to be printed
-     */
-    @Override
-    public void println(char x[])
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print a String and then terminate the line. This method behaves as though
-     * it invokes <code>{@link #print(String)}</code> and then
-     * <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the <code>String</code> value to be printed
-     */
-    @Override
-    public void println(String x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Print an Object and then terminate the line. This method behaves as
-     * though it invokes <code>{@link #print(Object)}</code> and then
-     * <code>{@link #println()}</code>.
-     * 
-     * @param x
-     *            the <code>Object</code> value to be printed
-     */
-    @Override
-    public void println(Object x)
-    {
-        synchronized (lock)
-        {
-            this.print(x);
-            this.println();
-        }
-    }
-}
diff -r 31e803481e33 -r d850a5e6ff15 src/org/eclipse/jetty/server/AbstractHttpConnection.java
--- a/src/org/eclipse/jetty/server/AbstractHttpConnection.java	Tue Oct 04 16:04:32 2016 -0600
+++ b/src/org/eclipse/jetty/server/AbstractHttpConnection.java	Tue Oct 04 16:12:50 2016 -0600
@@ -53,7 +53,6 @@
 import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.io.EofException;
 import org.eclipse.jetty.io.RuntimeIOException;
-import org.eclipse.jetty.io.UncheckedPrintWriter;
 import org.eclipse.jetty.server.handler.ErrorHandler;
 import org.eclipse.jetty.server.nio.NIOConnector;
 import org.eclipse.jetty.server.ssl.SslConnector;
@@ -366,26 +365,23 @@
 		if (_writer==null)
 		{
 			_writer=new OutputWriter();
-			if (_server.isUncheckedPrintWriter())
-				_printWriter=new UncheckedPrintWriter(_writer);
-			else
-				_printWriter = new PrintWriter(_writer)
+			_printWriter = new PrintWriter(_writer)
+			{
+				public void close()
 				{
-					public void close()
+					synchronized (lock)
 					{
-						synchronized (lock)
+						try
 						{
-							try
-							{
-								out.close();
-							}
-							catch (IOException e)
-							{
-								setError();
-							}
+							out.close();
+						}
+						catch (IOException e)
+						{
+							setError();
 						}
 					}
-				};
+				}
+			};
 		}
 		_writer.setCharacterEncoding(encoding);
 		return _printWriter;
diff -r 31e803481e33 -r d850a5e6ff15 src/org/eclipse/jetty/server/Server.java
--- a/src/org/eclipse/jetty/server/Server.java	Tue Oct 04 16:04:32 2016 -0600
+++ b/src/org/eclipse/jetty/server/Server.java	Tue Oct 04 16:12:50 2016 -0600
@@ -65,7 +65,6 @@
 	public final Connector connector;
 	private boolean _dumpAfterStart=false;
 	private boolean _dumpBeforeStop=false;
-	private boolean _uncheckedPrintWriter=false;
 
 
 	/* ------------------------------------------------------------ */
@@ -322,19 +321,6 @@
 
 
 	/* ------------------------------------------------------------ */
-	public boolean isUncheckedPrintWriter()
-	{
-		return _uncheckedPrintWriter;
-	}
-
-	/* ------------------------------------------------------------ */
-	public void setUncheckedPrintWriter(boolean unchecked)
-	{
-		_uncheckedPrintWriter=unchecked;
-	}
-
-
-	/* ------------------------------------------------------------ */
 	/* A handler that can be gracefully shutdown.
 	 * Called by doStop if a {@link #setGracefulShutdown} period is set.
 	 * TODO move this somewhere better