harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r492652 [9/13] - /harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/
Date Thu, 04 Jan 2007 17:47:05 GMT
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/ObjectStreamField.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/ObjectStreamField.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/ObjectStreamField.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/ObjectStreamField.java Thu Jan  4 09:47:01 2007
@@ -28,317 +28,318 @@
  * 
  * @see ObjectOutputStream#writeFields()
  * @see ObjectInputStream#readFields()
- * 
  */
 public class ObjectStreamField implements Comparable<Object> {
 
-	// Declared name of the field
-	private String name;
+    // Declared name of the field
+    private String name;
 
-	// Declared type of the field
-	private Object type;
+    // Declared type of the field
+    private Object type;
 
-	// offset of this field in the object
-	int offset;
+    // offset of this field in the object
+    int offset;
 
-	// Cached version of intern'ed type String
-	private String typeString;
+    // Cached version of intern'ed type String
+    private String typeString;
+
+    private boolean unshared;
 
-	private boolean unshared;
-    
     private boolean isDeserialized;
 
-	/**
-	 * Constructs an ObjectStreamField with the given name and the given type
-	 * 
-	 * @param name
-	 *            a String, the name of the field
-	 * @param cl
-	 *            A Class object representing the type of the field
-	 */
-	public ObjectStreamField(String name, Class<?> cl) {
-		if (name == null || cl == null) {
-			throw new NullPointerException();
-		}
-		this.name = name;
-		this.type = new WeakReference<Class<?>>(cl);
-	}
-
-	/**
-	 * Constructs an ObjectStreamField with the given name and the given type
-	 * 
-	 * @param name
-	 *            a String, the name of the field
-	 * @param cl
-	 *            A Class object representing the type of the field
-	 * @param unshared
-	 *            write and read the field unshared
-	 */
-	public ObjectStreamField(String name, Class<?> cl, boolean unshared) {
-		if (name == null || cl == null) {
-			throw new NullPointerException();
-		}
-		this.name = name;
-		this.type = (cl.getClassLoader() == null) ? cl
-				: new WeakReference<Class<?>>(cl);
-		this.unshared = unshared;
-	}
-
-	/**
-	 * Constructs an ObjectStreamField with the given name and the given type.
-	 * The type may be null.
-	 * 
-	 * @param signature
-	 *            A String representing the type of the field
-	 * @param name
-	 *            a String, the name of the field, or null
-	 */
-	ObjectStreamField(String signature, String name) {
-		if (name == null) {
-			throw new NullPointerException();
-		}
-		this.name = name;
-		this.typeString = signature.replace('.', '/');
+    /**
+     * Constructs an ObjectStreamField with the given name and the given type
+     * 
+     * @param name
+     *            a String, the name of the field
+     * @param cl
+     *            A Class object representing the type of the field
+     */
+    public ObjectStreamField(String name, Class<?> cl) {
+        if (name == null || cl == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.type = new WeakReference<Class<?>>(cl);
+    }
+
+    /**
+     * Constructs an ObjectStreamField with the given name and the given type
+     * 
+     * @param name
+     *            a String, the name of the field
+     * @param cl
+     *            A Class object representing the type of the field
+     * @param unshared
+     *            write and read the field unshared
+     */
+    public ObjectStreamField(String name, Class<?> cl, boolean unshared) {
+        if (name == null || cl == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.type = (cl.getClassLoader() == null) ? cl
+                : new WeakReference<Class<?>>(cl);
+        this.unshared = unshared;
+    }
+
+    /**
+     * Constructs an ObjectStreamField with the given name and the given type.
+     * The type may be null.
+     * 
+     * @param signature
+     *            A String representing the type of the field
+     * @param name
+     *            a String, the name of the field, or null
+     */
+    ObjectStreamField(String signature, String name) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.typeString = signature.replace('.', '/');
         this.isDeserialized = true;
-	}
+    }
+
+    /**
+     * Comparing the receiver to the parameter, according to the Comparable
+     * interface.
+     * 
+     * @param o
+     *            The object to compare against
+     * 
+     * @return -1 if the receiver is "smaller" than the parameter. 0 if the
+     *         receiver is "equal" to the parameter. 1 if the receiver is
+     *         "greater" than the parameter.
+     */
+    public int compareTo(Object o) {
+        ObjectStreamField f = (ObjectStreamField) o;
+        boolean thisPrimitive = this.isPrimitive();
+        boolean fPrimitive = f.isPrimitive();
+
+        // If one is primitive and the other isn't, we have enough info to
+        // compare
+        if (thisPrimitive != fPrimitive) {
+            return thisPrimitive ? -1 : 1;
+        }
 
-	/**
-	 * Comparing the receiver to the parameter, according to the Comparable
-	 * interface.
-	 * 
-	 * @param o
-	 *            The object to compare against
-	 * 
-	 * @return -1 if the receiver is "smaller" than the parameter. 0 if the
-	 *         receiver is "equal" to the parameter. 1 if the receiver is
-	 *         "greater" than the parameter.
-	 */
-	public int compareTo(Object o) {
-		ObjectStreamField f = (ObjectStreamField) o;
-		boolean thisPrimitive = this.isPrimitive();
-		boolean fPrimitive = f.isPrimitive();
-
-		// If one is primitive and the other isn't, we have enough info to
-		// compare
-		if (thisPrimitive != fPrimitive) {
-			return thisPrimitive ? -1 : 1;
-		}
-
-		// Either both primitives or both not primitives. Compare based on name.
-		return this.getName().compareTo(f.getName());
-	}
-    
-    
+        // Either both primitives or both not primitives. Compare based on name.
+        return this.getName().compareTo(f.getName());
+    }
+
+    @Override
     public boolean equals(Object arg0) {
         return compareTo(arg0) == 0;
     }
-    
+
+    @Override
     public int hashCode() {
         return getName().hashCode();
     }
 
-	/**
-	 * Return the name of the field the receiver represents
-	 * 
-	 * @return a String, the name of the field
-	 */
-	public String getName() {
-		return name;
-	}
-
-	/**
-	 * Return the offset of this field in the object
-	 * 
-	 * @return an int, the offset
-	 */
-	public int getOffset() {
-		return offset;
-	}
-
-	/**
-	 * Return the type of the field the receiver represents,
-     * this is an internal method
-	 * 
-	 * @return A Class object representing the type of the field
-	 */
-	private Class<?> getTypeInternal() {
-		if (type instanceof WeakReference) {
-			return (Class<?>)((WeakReference<?>) type).get();
-		}
-		return (Class<?>) type;
-	}
-    
+    /**
+     * Return the name of the field the receiver represents
+     * 
+     * @return a String, the name of the field
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Return the offset of this field in the object
+     * 
+     * @return an int, the offset
+     */
+    public int getOffset() {
+        return offset;
+    }
+
+    /**
+     * Return the type of the field the receiver represents, this is an internal
+     * method
+     * 
+     * @return A Class object representing the type of the field
+     */
+    private Class<?> getTypeInternal() {
+        if (type instanceof WeakReference) {
+            return (Class<?>) ((WeakReference<?>) type).get();
+        }
+        return (Class<?>) type;
+    }
+
     /**
      * Return the type of the field the receiver represents
      * 
      * @return A Class object representing the type of the field
      */
     public Class<?> getType() {
-    	Class<?> cl = getTypeInternal();
+        Class<?> cl = getTypeInternal();
         if (isDeserialized && !cl.isPrimitive()) {
             return Object.class;
         }
         return cl;
     }
 
-	/**
-	 * Return the type code that corresponds to the class the receiver
-	 * represents
-	 * 
-	 * @return A char, the typecode of the class
-	 */
-	public char getTypeCode() {
-		Class<?> t = getTypeInternal();
-		if (t == Integer.TYPE) {
-			return 'I';
-		}
-		if (t == Byte.TYPE) {
-			return 'B';
-		}
-		if (t == Character.TYPE) {
-			return 'C';
-		}
-		if (t == Short.TYPE) {
-			return 'S';
-		}
-		if (t == Boolean.TYPE) {
-			return 'Z';
-		}
-		if (t == Long.TYPE) {
-			return 'J';
-		}
-		if (t == Float.TYPE) {
-			return 'F';
-		}
-		if (t == Double.TYPE) {
-			return 'D';
-		}
-		if (t.isArray()) {
-			return '[';
-		}
-		return 'L';
-	}
-
-	/**
-	 * Return the type signature used by the VM to represent the type for this
-	 * field.
-	 * 
-	 * @return A String, the signature for the class of this field.
-	 */
-	public String getTypeString() {
-		if (isPrimitive()) {
-			return null;
-		}
-		if (typeString == null) {
-			Class<?> t = getTypeInternal();
-			String typeName = t.getName().replace('.', '/');
-			String str = (t.isArray()) ? typeName : ("L" + typeName + ';'); //$NON-NLS-1$
-			typeString = str.intern();
-		}
-		return typeString;
-	}
-
-	/**
-	 * Return a boolean indicating whether the class of this field is a
-	 * primitive type or not
-	 * 
-	 * @return true if the type of this field is a primitive type false if the
-	 *         type of this field is a regular class.
-	 */
-	public boolean isPrimitive() {
-		Class<?> t = getTypeInternal();
-		return t != null && t.isPrimitive();
-	}
-
-	/**
-	 * Set the offset this field represents in the object
-	 * 
-	 * @param newValue
-	 *            an int, the offset
-	 */
-	protected void setOffset(int newValue) {
-		this.offset = newValue;
-	}
-
-	/**
-	 * Answers a string containing a concise, human-readable description of the
-	 * receiver.
-	 * 
-	 * @return a printable representation for the receiver.
-	 */
-	@Override
+    /**
+     * Return the type code that corresponds to the class the receiver
+     * represents
+     * 
+     * @return A char, the typecode of the class
+     */
+    public char getTypeCode() {
+        Class<?> t = getTypeInternal();
+        if (t == Integer.TYPE) {
+            return 'I';
+        }
+        if (t == Byte.TYPE) {
+            return 'B';
+        }
+        if (t == Character.TYPE) {
+            return 'C';
+        }
+        if (t == Short.TYPE) {
+            return 'S';
+        }
+        if (t == Boolean.TYPE) {
+            return 'Z';
+        }
+        if (t == Long.TYPE) {
+            return 'J';
+        }
+        if (t == Float.TYPE) {
+            return 'F';
+        }
+        if (t == Double.TYPE) {
+            return 'D';
+        }
+        if (t.isArray()) {
+            return '[';
+        }
+        return 'L';
+    }
+
+    /**
+     * Return the type signature used by the VM to represent the type for this
+     * field.
+     * 
+     * @return A String, the signature for the class of this field.
+     */
+    public String getTypeString() {
+        if (isPrimitive()) {
+            return null;
+        }
+        if (typeString == null) {
+            Class<?> t = getTypeInternal();
+            String typeName = t.getName().replace('.', '/');
+            String str = (t.isArray()) ? typeName : ("L" + typeName + ';'); //$NON-NLS-1$
+            typeString = str.intern();
+        }
+        return typeString;
+    }
+
+    /**
+     * Return a boolean indicating whether the class of this field is a
+     * primitive type or not
+     * 
+     * @return true if the type of this field is a primitive type false if the
+     *         type of this field is a regular class.
+     */
+    public boolean isPrimitive() {
+        Class<?> t = getTypeInternal();
+        return t != null && t.isPrimitive();
+    }
+
+    /**
+     * Set the offset this field represents in the object
+     * 
+     * @param newValue
+     *            an int, the offset
+     */
+    protected void setOffset(int newValue) {
+        this.offset = newValue;
+    }
+
+    /**
+     * Answers a string containing a concise, human-readable description of the
+     * receiver.
+     * 
+     * @return a printable representation for the receiver.
+     */
+    @Override
     public String toString() {
-		return this.getClass().getName() + '(' + getName() + ':' + getTypeInternal()
-				+ ')';
-	}
-
-	/**
-	 * Sorts the fields for dumping. Primitive types come first, then regular
-	 * types.
-	 * 
-	 * @param fields
-	 *            ObjectStreamField[] fields to be sorted
-	 */
-	static void sortFields(ObjectStreamField[] fields) {
-		// Sort if necessary
-		if (fields.length > 1) {
-			Comparator<ObjectStreamField> fieldDescComparator = new Comparator<ObjectStreamField>() {
-				public int compare(ObjectStreamField f1, ObjectStreamField f2) {
-					return f1.compareTo(f2);
-				}
-			};
-			Arrays.sort(fields, fieldDescComparator);
-		}
-	}
-
-	void resolve(ClassLoader loader) {
-		if (typeString.length() == 1) {
-			switch (typeString.charAt(0)) {
-			case 'I':
-				type = Integer.TYPE;
-				return;
-			case 'B':
-				type = Byte.TYPE;
-				return;
-			case 'C':
-				type = Character.TYPE;
-				return;
-			case 'S':
-				type = Short.TYPE;
-				return;
-			case 'Z':
-				type = Boolean.TYPE;
-				return;
-			case 'J':
-				type = Long.TYPE;
-				return;
-			case 'F':
-				type = Float.TYPE;
-				return;
-			case 'D':
-				type = Double.TYPE;
-				return;
-			}
-		}
-		String className = typeString.replace('/', '.');
-		if (className.charAt(0) == 'L') {
-			// remove L and ;
-			className = className.substring(1, className.length() - 1);
-		}
-		try {
-			Class<?> cl = Class.forName(className, false, loader);
-			type = (cl.getClassLoader() == null) ? cl : new WeakReference<Class<?>>(cl);
-		} catch (ClassNotFoundException e) {
-			// Ignored
-		}
-	}
-
-	/**
-	 * Answers whether this serialized field is unshared.
-	 * 
-	 * @return true if the field is unshared, false otherwise.
-	 */
-	public boolean isUnshared() {
-		return unshared;
-	}
+        return this.getClass().getName() + '(' + getName() + ':'
+                + getTypeInternal() + ')';
+    }
+
+    /**
+     * Sorts the fields for dumping. Primitive types come first, then regular
+     * types.
+     * 
+     * @param fields
+     *            ObjectStreamField[] fields to be sorted
+     */
+    static void sortFields(ObjectStreamField[] fields) {
+        // Sort if necessary
+        if (fields.length > 1) {
+            Comparator<ObjectStreamField> fieldDescComparator = new Comparator<ObjectStreamField>() {
+                public int compare(ObjectStreamField f1, ObjectStreamField f2) {
+                    return f1.compareTo(f2);
+                }
+            };
+            Arrays.sort(fields, fieldDescComparator);
+        }
+    }
+
+    void resolve(ClassLoader loader) {
+        if (typeString.length() == 1) {
+            switch (typeString.charAt(0)) {
+                case 'I':
+                    type = Integer.TYPE;
+                    return;
+                case 'B':
+                    type = Byte.TYPE;
+                    return;
+                case 'C':
+                    type = Character.TYPE;
+                    return;
+                case 'S':
+                    type = Short.TYPE;
+                    return;
+                case 'Z':
+                    type = Boolean.TYPE;
+                    return;
+                case 'J':
+                    type = Long.TYPE;
+                    return;
+                case 'F':
+                    type = Float.TYPE;
+                    return;
+                case 'D':
+                    type = Double.TYPE;
+                    return;
+            }
+        }
+        String className = typeString.replace('/', '.');
+        if (className.charAt(0) == 'L') {
+            // remove L and ;
+            className = className.substring(1, className.length() - 1);
+        }
+        try {
+            Class<?> cl = Class.forName(className, false, loader);
+            type = (cl.getClassLoader() == null) ? cl
+                    : new WeakReference<Class<?>>(cl);
+        } catch (ClassNotFoundException e) {
+            // Ignored
+        }
+    }
+
+    /**
+     * Answers whether this serialized field is unshared.
+     * 
+     * @return true if the field is unshared, false otherwise.
+     */
+    public boolean isUnshared() {
+        return unshared;
+    }
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OptionalDataException.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OptionalDataException.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OptionalDataException.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OptionalDataException.java Thu Jan  4 09:47:01 2007
@@ -16,6 +16,7 @@
  */
 
 package java.io;
+
 /**
  * When readObject() encounters primitive types (int, char, etc) instead of an
  * object instance in the input stream, this type of exception will be thrown.
@@ -26,34 +27,33 @@
  */
 public class OptionalDataException extends ObjectStreamException {
 
-	private static final long serialVersionUID = -8011121865681257820L;
-
-	/**
-	 * If true it means there is no more primitive data available.
-	 */
-	public boolean eof;
-
-	/**
-	 * Number of bytes of primitive data (int, char, long, etc).
-	 */
-	public int length;
-
-	/**
-	 * Constructs a new instance of this class with its walkback filled in.
-	 */
-	OptionalDataException() {
-		super();
-	}
-
-	/**
-	 * Constructs a new instance of this class with its walkback and message
-	 * filled in.
-	 * 
-	 * @param detailMessage
-	 *            String The detail message for the exception.
-	 */
-	OptionalDataException(String detailMessage) {
-		super(detailMessage);
-	}
+    private static final long serialVersionUID = -8011121865681257820L;
 
+    /**
+     * If true it means there is no more primitive data available.
+     */
+    public boolean eof;
+
+    /**
+     * Number of bytes of primitive data (int, char, long, etc).
+     */
+    public int length;
+
+    /**
+     * Constructs a new instance of this class with its walkback filled in.
+     */
+    OptionalDataException() {
+        super();
+    }
+
+    /**
+     * Constructs a new instance of this class with its walkback and message
+     * filled in.
+     * 
+     * @param detailMessage
+     *            String The detail message for the exception.
+     */
+    OptionalDataException(String detailMessage) {
+        super(detailMessage);
+    }
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStream.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStream.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStream.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStream.java Thu Jan  4 09:47:01 2007
@@ -17,6 +17,7 @@
 
 package java.io;
 
+import org.apache.harmony.luni.util.Msg;
 
 /**
  * OutputStream is an abstract class for all byte output streams. It provides
@@ -24,97 +25,89 @@
  * 
  * @see InputStream
  */
+public abstract class OutputStream implements Closeable, Flushable {
 
-public abstract class OutputStream implements Closeable,Flushable{
-	/**
-	 * This constructor does nothing interesting. Provided for signature
-	 * compatibility.
-	 * 
-	 */
-
-	public OutputStream() {
-		/*empty*/
-	}
-
-	/**
-	 * Close this OutputStream. Concrete implementations of this class should
-	 * free any resources during close. This implementation does nothing.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to close this OutputStream.
-	 */
-
-	public void close() throws IOException {
-		/*empty*/
-	}
-
-	/**
-	 * Flush this OutputStream. Concrete implementations of this class should
-	 * ensure any pending writes to the underlying stream are written out when
-	 * this method is envoked. This implementation does nothing.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to flush this OutputStream.
-	 */
-
-	public void flush() throws IOException {
-		/*empty */
-	}
-
-	/**
-	 * Writes the entire contents of the byte array <code>buffer</code> to
-	 * this OutputStream.
-	 * 
-	 * @param buffer
-	 *            the buffer to be written
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to write to this OutputStream.
-	 */
-
-	public void write(byte buffer[]) throws IOException {
-		write(buffer, 0, buffer.length);
-	}
-
-	/**
-	 * Writes <code>count</code> <code>bytes</code> from the byte array
-	 * <code>buffer</code> starting at <code>offset</code> to this
-	 * OutputStream.
-	 * 
-	 * @param buffer
-	 *            the buffer to be written
-	 * @param offset
-	 *            offset in buffer to get bytes
-	 * @param count
-	 *            number of bytes in buffer to write
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to write to this OutputStream.
-	 * @throws IndexOutOfBoundsException
-	 *             If offset or count are outside of bounds.
-	 */
-
-	public void write(byte buffer[], int offset, int count) throws IOException {
-		// avoid int overflow, check null buffer
-		if (offset <= buffer.length && 0 <= offset && 0 <= count
-				&& count <= buffer.length - offset) {
-			for (int i = offset; i < offset + count; i++)
-				write(buffer[i]);
-		} else
-			throw new IndexOutOfBoundsException(org.apache.harmony.luni.util.Msg
-					.getString("K002f")); //$NON-NLS-1$
-	}
-
-	/**
-	 * Writes the specified byte <code>oneByte</code> to this OutputStream.
-	 * Only the low order byte of <code>oneByte</code> is written.
-	 * 
-	 * @param oneByte
-	 *            the byte to be written
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to write to this OutputStream.
-	 */
-
-	public abstract void write(int oneByte) throws IOException;
+    /**
+     * Default constructor.
+     */
+    public OutputStream() {
+        super();
+    }
+
+    /**
+     * Close this OutputStream. Concrete implementations of this class should
+     * free any resources during close. This implementation does nothing.
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to close this OutputStream.
+     */
+    public void close() throws IOException {
+        /* empty */
+    }
+
+    /**
+     * Flush this OutputStream. Concrete implementations of this class should
+     * ensure any pending writes to the underlying stream are written out when
+     * this method is envoked. This implementation does nothing.
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to flush this OutputStream.
+     */
+    public void flush() throws IOException {
+        /* empty */
+    }
+
+    /**
+     * Writes the entire contents of the byte array <code>buffer</code> to
+     * this OutputStream.
+     * 
+     * @param buffer
+     *            the buffer to be written
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to write to this OutputStream.
+     */
+    public void write(byte buffer[]) throws IOException {
+        write(buffer, 0, buffer.length);
+    }
+
+    /**
+     * Writes <code>count</code> <code>bytes</code> from the byte array
+     * <code>buffer</code> starting at <code>offset</code> to this
+     * OutputStream.
+     * 
+     * @param buffer
+     *            the buffer to be written
+     * @param offset
+     *            offset in buffer to get bytes
+     * @param count
+     *            number of bytes in buffer to write
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to write to this OutputStream.
+     * @throws IndexOutOfBoundsException
+     *             If offset or count are outside of bounds.
+     */
+    public void write(byte buffer[], int offset, int count) throws IOException {
+        // avoid int overflow, check null buffer
+        if (offset < 0 || offset > buffer.length || count < 0
+                || count > buffer.length - offset) {
+            throw new IndexOutOfBoundsException(Msg.getString("K002f")); //$NON-NLS-1$
+        }
+        for (int i = offset; i < offset + count; i++) {
+            write(buffer[i]);
+        }
+    }
+
+    /**
+     * Writes the specified byte <code>oneByte</code> to this OutputStream.
+     * Only the low order byte of <code>oneByte</code> is written.
+     * 
+     * @param oneByte
+     *            the byte to be written
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to write to this OutputStream.
+     */
+    public abstract void write(int oneByte) throws IOException;
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStreamWriter.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStreamWriter.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStreamWriter.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/OutputStreamWriter.java Thu Jan  4 09:47:01 2007
@@ -15,8 +15,7 @@
  *  limitations under the License.
  */
 
-package java.io; 
-
+package java.io;
 
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
@@ -26,6 +25,7 @@
 import java.nio.charset.CodingErrorAction;
 import java.security.AccessController;
 
+import org.apache.harmony.luni.util.Msg;
 import org.apache.harmony.luni.util.PriviAction;
 
 /**
@@ -35,283 +35,279 @@
  * ISO8859_1 (ISO-Latin-1) but can be changed by calling the constructor which
  * takes an encoding.
  * 
- * 
  * @see InputStreamReader
  */
 
 public class OutputStreamWriter extends Writer {
-	private OutputStream out;
 
-	private CharsetEncoder encoder;
+    private OutputStream out;
+
+    private CharsetEncoder encoder;
 
-	private ByteBuffer bytes = ByteBuffer.allocate(8192);
+    private ByteBuffer bytes = ByteBuffer.allocate(8192);
 
-	/**
-	 * Constructs a new OutputStreamWriter using <code>out</code> as the
-	 * OutputStream to write converted characters to. The default character
-	 * encoding is used (see class description).
-	 * 
-	 * @param out
-	 *            the non-null OutputStream to write converted bytes to.
-	 */
-
-	public OutputStreamWriter(OutputStream out) {
-		super(out);
-		this.out = out;
-		String encoding = AccessController
+    /**
+     * Constructs a new OutputStreamWriter using <code>out</code> as the
+     * OutputStream to write converted characters to. The default character
+     * encoding is used (see class description).
+     * 
+     * @param out
+     *            the non-null OutputStream to write converted bytes to.
+     */
+    public OutputStreamWriter(OutputStream out) {
+        super(out);
+        this.out = out;
+        String encoding = AccessController
                 .doPrivileged(new PriviAction<String>(
                         "file.encoding", "ISO8859_1")); //$NON-NLS-1$ //$NON-NLS-2$
-		encoder = Charset.forName(encoding).newEncoder();
-		encoder.onMalformedInput(CodingErrorAction.REPLACE);
-		encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
-	}
-
-	/**
-	 * Constructs a new OutputStreamWriter using <code>out</code> as the
-	 * OutputStream to write converted characters to and <code>enc</code> as
-	 * the character encoding. If the encoding cannot be found, an
-	 * UnsupportedEncodingException error is thrown.
-	 * 
-	 * @param out
-	 *            the non-null OutputStream to write converted bytes to.
-	 * @param enc
-	 *            the non-null String describing the desired character encoding.
-	 * 
-	 * @throws UnsupportedEncodingException
-	 *             if the encoding cannot be found.
-	 */
-
-	public OutputStreamWriter(OutputStream out, final String enc)
-			throws UnsupportedEncodingException {
-		super(out);
-        if(enc == null) {
+        encoder = Charset.forName(encoding).newEncoder();
+        encoder.onMalformedInput(CodingErrorAction.REPLACE);
+        encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+    }
+
+    /**
+     * Constructs a new OutputStreamWriter using <code>out</code> as the
+     * OutputStream to write converted characters to and <code>enc</code> as
+     * the character encoding. If the encoding cannot be found, an
+     * UnsupportedEncodingException error is thrown.
+     * 
+     * @param out
+     *            the non-null OutputStream to write converted bytes to.
+     * @param enc
+     *            the non-null String describing the desired character encoding.
+     * 
+     * @throws UnsupportedEncodingException
+     *             if the encoding cannot be found.
+     */
+    public OutputStreamWriter(OutputStream out, final String enc)
+            throws UnsupportedEncodingException {
+        super(out);
+        if (enc == null) {
             throw new NullPointerException();
         }
-		this.out = out;
-		try {
-			encoder = Charset.forName(enc).newEncoder();
-		} catch (Exception e) {
-			throw new UnsupportedEncodingException(enc);
-		}
-		encoder.onMalformedInput(CodingErrorAction.REPLACE);
-		encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
-	}
-
-	/**
-	 * Constructs a new OutputStreamWriter using <code>out</code> as the
-	 * OutputStream to write converted characters to and <code>cs</code> as
-	 * the character encoding.
-	 * 
-	 * 
-	 * @param out
-	 *            the non-null OutputStream to write converted bytes to.
-	 * @param cs
-	 *            the non-null Charset which specify the character encoding.
-	 */
-	public OutputStreamWriter(OutputStream out, Charset cs) {
-		super(out);
-		this.out = out;
-		encoder = cs.newEncoder();
-		encoder.onMalformedInput(CodingErrorAction.REPLACE);
-		encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
-	}
-
-	/**
-	 * Constructs a new OutputStreamWriter using <code>out</code> as the
-	 * OutputStream to write converted characters to and <code>enc</code> as
-	 * the character encoding.
-	 * 
-	 * 
-	 * @param out
-	 *            the non-null OutputStream to write converted bytes to.
-	 * @param enc
-	 *            the non-null CharsetEncoder which used to character encoding.
-	 */
-	public OutputStreamWriter(OutputStream out, CharsetEncoder enc) {
-		super(out);
-		enc.charset();
-		this.out = out;
-		encoder = enc;
-	}
-
-	/**
-	 * Close this OutputStreamWriter. This implementation first flushes the
-	 * buffer and the target OutputStream. The OutputStream is then closed and
-	 * the resources for the buffer and converter are freed.
-	 * <p>
-	 * Only the first invocation of this method has any effect. Subsequent calls
-	 * do no work.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to close this
-	 *             OutputStreamWriter.
-	 */
-	@Override
+        this.out = out;
+        try {
+            encoder = Charset.forName(enc).newEncoder();
+        } catch (Exception e) {
+            throw new UnsupportedEncodingException(enc);
+        }
+        encoder.onMalformedInput(CodingErrorAction.REPLACE);
+        encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+    }
+
+    /**
+     * Constructs a new OutputStreamWriter using <code>out</code> as the
+     * OutputStream to write converted characters to and <code>cs</code> as
+     * the character encoding.
+     * 
+     * 
+     * @param out
+     *            the non-null OutputStream to write converted bytes to.
+     * @param cs
+     *            the non-null Charset which specify the character encoding.
+     */
+    public OutputStreamWriter(OutputStream out, Charset cs) {
+        super(out);
+        this.out = out;
+        encoder = cs.newEncoder();
+        encoder.onMalformedInput(CodingErrorAction.REPLACE);
+        encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+    }
+
+    /**
+     * Constructs a new OutputStreamWriter using <code>out</code> as the
+     * OutputStream to write converted characters to and <code>enc</code> as
+     * the character encoding.
+     * 
+     * @param out
+     *            the non-null OutputStream to write converted bytes to.
+     * @param enc
+     *            the non-null CharsetEncoder which used to character encoding.
+     */
+    public OutputStreamWriter(OutputStream out, CharsetEncoder enc) {
+        super(out);
+        enc.charset();
+        this.out = out;
+        encoder = enc;
+    }
+
+    /**
+     * Close this OutputStreamWriter. This implementation first flushes the
+     * buffer and the target OutputStream. The OutputStream is then closed and
+     * the resources for the buffer and converter are freed.
+     * <p>
+     * Only the first invocation of this method has any effect. Subsequent calls
+     * do no work.
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to close this
+     *             OutputStreamWriter.
+     */
+    @Override
     public void close() throws IOException {
-		synchronized (lock) {
-			if (encoder != null) {
-				encoder.flush(bytes);
-				flush();
-				out.flush();
-				out.close();
-				encoder = null;
-				bytes = null;
-			}
-		}
-	}
-
-	/**
-	 * Flush this OutputStreamWriter. This implementation ensures all buffered
-	 * bytes are written to the target OutputStream. After writing the bytes,
-	 * the target OutputStream is then flushed.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to flush this
-	 *             OutputStreamWriter.
-	 */
+        synchronized (lock) {
+            if (encoder != null) {
+                encoder.flush(bytes);
+                flush();
+                out.flush();
+                out.close();
+                encoder = null;
+                bytes = null;
+            }
+        }
+    }
 
-	@Override
+    /**
+     * Flush this OutputStreamWriter. This implementation ensures all buffered
+     * bytes are written to the target OutputStream. After writing the bytes,
+     * the target OutputStream is then flushed.
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to flush this
+     *             OutputStreamWriter.
+     */
+    @Override
     public void flush() throws IOException {
-		synchronized (lock) {
-			checkStatus();
-			int position;
-			if ((position = bytes.position()) > 0) {
-				bytes.flip();
-				out.write(bytes.array(), 0, position);
-				bytes.clear();
-			}
-			out.flush();
-		}
-	}
-
-	private void checkStatus() throws IOException {
-		if (encoder == null) {
-			throw new IOException("This writer has been closed!"); //$NON-NLS-1$
-		}
-	}
-
-	/**
-	 * Answer the String which identifies the encoding used to convert
-	 * characters to bytes. The value <code>null</code> is returned if this
-	 * Writer has been closed.
-	 * 
-	 * @return the String describing the converter or null if this Writer is
-	 *         closed.
-	 */
-
-	public String getEncoding() {
-		if (encoder == null) {
-			return null;
-		}
-		return InputStreamReader.HistoricalNamesUtil.getHistoricalName(encoder
-				.charset().name());
-	}
-
-	/**
-	 * Writes <code>count</code> characters starting at <code>offset</code>
-	 * in <code>buf</code> to this Writer. The characters are immediately
-	 * converted to bytes by the character converter and stored in a local
-	 * buffer. If the buffer becomes full as a result of this write, this Writer
-	 * is flushed.
-	 * 
-	 * @param buf
-	 *            the non-null array containing characters to write.
-	 * @param offset
-	 *            offset in buf to retrieve characters
-	 * @param count
-	 *            maximum number of characters to write
-	 * 
-	 * @throws IOException
-	 *             If this OutputStreamWriter has already been closed or some
-	 *             other IOException occurs.
-	 * @throws IndexOutOfBoundsException
-	 *             If offset or count is outside of bounds.
-	 */
-	@Override
+        synchronized (lock) {
+            checkStatus();
+            int position;
+            if ((position = bytes.position()) > 0) {
+                bytes.flip();
+                out.write(bytes.array(), 0, position);
+                bytes.clear();
+            }
+            out.flush();
+        }
+    }
+
+    private void checkStatus() throws IOException {
+        if (encoder == null) {
+            // K005d=Writer is closed.
+            throw new IOException(Msg.getString("K005d")); //$NON-NLS-1$
+        }
+    }
+
+    /**
+     * Answer the String which identifies the encoding used to convert
+     * characters to bytes. The value <code>null</code> is returned if this
+     * Writer has been closed.
+     * 
+     * @return the String describing the converter or null if this Writer is
+     *         closed.
+     */
+
+    public String getEncoding() {
+        if (encoder == null) {
+            return null;
+        }
+        return InputStreamReader.HistoricalNamesUtil.getHistoricalName(encoder
+                .charset().name());
+    }
+
+    /**
+     * Writes <code>count</code> characters starting at <code>offset</code>
+     * in <code>buf</code> to this Writer. The characters are immediately
+     * converted to bytes by the character converter and stored in a local
+     * buffer. If the buffer becomes full as a result of this write, this Writer
+     * is flushed.
+     * 
+     * @param buf
+     *            the non-null array containing characters to write.
+     * @param offset
+     *            offset in buf to retrieve characters
+     * @param count
+     *            maximum number of characters to write
+     * 
+     * @throws IOException
+     *             If this OutputStreamWriter has already been closed or some
+     *             other IOException occurs.
+     * @throws IndexOutOfBoundsException
+     *             If offset or count is outside of bounds.
+     */
+    @Override
     public void write(char[] buf, int offset, int count) throws IOException {
-		synchronized (lock) {
-			checkStatus();
-			if (offset < 0 || offset > buf.length - count || count < 0) {
-				throw new IndexOutOfBoundsException();
-			}
-			CharBuffer chars = CharBuffer.wrap(buf, offset, count);
-			convert(chars);
-		}
-	}
-
-	private void convert(CharBuffer chars) throws IOException {
-		CoderResult result = encoder.encode(chars, bytes, true);
-		while (true) {
-			if (result.isError()) {
-				throw new IOException(result.toString());
-			} else if (result.isOverflow()) {
-				//flush the output buffer
-				flush();
-				result = encoder.encode(chars, bytes, true);
-				continue;
-			}
-			break;
-		}
-	}
-
-	/**
-	 * Writes out the character <code>oneChar</code> to this Writer. The
-	 * low-order 2 bytes are immediately converted to bytes by the character
-	 * converter and stored in a local buffer. If the buffer becomes full as a
-	 * result of this write, this Writer is flushed.
-	 * 
-	 * @param oneChar
-	 *            the character to write
-	 * 
-	 * @throws IOException
-	 *             If this OutputStreamWriter has already been closed or some
-	 *             other IOException occurs.
-	 */
-	@Override
+        synchronized (lock) {
+            checkStatus();
+            if (offset < 0 || offset > buf.length - count || count < 0) {
+                throw new IndexOutOfBoundsException();
+            }
+            CharBuffer chars = CharBuffer.wrap(buf, offset, count);
+            convert(chars);
+        }
+    }
+
+    private void convert(CharBuffer chars) throws IOException {
+        CoderResult result = encoder.encode(chars, bytes, true);
+        while (true) {
+            if (result.isError()) {
+                throw new IOException(result.toString());
+            } else if (result.isOverflow()) {
+                // flush the output buffer
+                flush();
+                result = encoder.encode(chars, bytes, true);
+                continue;
+            }
+            break;
+        }
+    }
+
+    /**
+     * Writes out the character <code>oneChar</code> to this Writer. The
+     * low-order 2 bytes are immediately converted to bytes by the character
+     * converter and stored in a local buffer. If the buffer becomes full as a
+     * result of this write, this Writer is flushed.
+     * 
+     * @param oneChar
+     *            the character to write
+     * 
+     * @throws IOException
+     *             If this OutputStreamWriter has already been closed or some
+     *             other IOException occurs.
+     */
+    @Override
     public void write(int oneChar) throws IOException {
-		synchronized (lock) {
-			checkStatus();
-			CharBuffer chars = CharBuffer.wrap(new char[] { (char) oneChar });
-			convert(chars);
-		}
-	}
-
-	/**
-	 * Writes <code>count</code> characters starting at <code>offset</code>
-	 * in <code>str</code> to this Writer. The characters are immediately
-	 * converted to bytes by the character converter and stored in a local
-	 * buffer. If the buffer becomes full as a result of this write, this Writer
-	 * is flushed.
-	 * 
-	 * @param str
-	 *            the non-null String containing characters to write.
-	 * @param offset
-	 *            offset in str to retrieve characters
-	 * @param count
-	 *            maximum number of characters to write
-	 * 
-	 * @throws IOException
-	 *             If this OutputStreamWriter has already been closed or some
-	 *             other IOException occurs.
-	 * @throws IndexOutOfBoundsException    
-	 *             If count is negative    
-	 * @throws StringIndexOutOfBoundsException
-	 *             If offset is negative or offset + count is outside of bounds
-	 */
-	@Override
+        synchronized (lock) {
+            checkStatus();
+            CharBuffer chars = CharBuffer.wrap(new char[] { (char) oneChar });
+            convert(chars);
+        }
+    }
+
+    /**
+     * Writes <code>count</code> characters starting at <code>offset</code>
+     * in <code>str</code> to this Writer. The characters are immediately
+     * converted to bytes by the character converter and stored in a local
+     * buffer. If the buffer becomes full as a result of this write, this Writer
+     * is flushed.
+     * 
+     * @param str
+     *            the non-null String containing characters to write.
+     * @param offset
+     *            offset in str to retrieve characters
+     * @param count
+     *            maximum number of characters to write
+     * 
+     * @throws IOException
+     *             If this OutputStreamWriter has already been closed or some
+     *             other IOException occurs.
+     * @throws IndexOutOfBoundsException
+     *             If count is negative
+     * @throws StringIndexOutOfBoundsException
+     *             If offset is negative or offset + count is outside of bounds
+     */
+    @Override
     public void write(String str, int offset, int count) throws IOException {
-		synchronized (lock) {
-			// avoid int overflow
-			if (count < 0) {
-				throw new IndexOutOfBoundsException();
-			}
-			if (offset > str.length() - count || offset < 0) {
-				throw new StringIndexOutOfBoundsException();
-			}
-			checkStatus();
-			CharBuffer chars = CharBuffer.wrap(str, offset, count + offset);
-			convert(chars);
-		}
-	}
+        synchronized (lock) {
+            // avoid int overflow
+            if (count < 0) {
+                throw new IndexOutOfBoundsException();
+            }
+            if (offset > str.length() - count || offset < 0) {
+                throw new StringIndexOutOfBoundsException();
+            }
+            checkStatus();
+            CharBuffer chars = CharBuffer.wrap(str, offset, count + offset);
+            convert(chars);
+        }
+    }
 }
-

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedInputStream.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedInputStream.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedInputStream.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedInputStream.java Thu Jan  4 09:47:01 2007
@@ -17,6 +17,7 @@
 
 package java.io;
 
+import org.apache.harmony.luni.util.Msg;
 
 /**
  * PipedInputStream is a class which receives information on a communications
@@ -26,333 +27,332 @@
  * @see PipedOutputStream
  */
 public class PipedInputStream extends InputStream {
-	private Thread lastReader, lastWriter;
 
-	private boolean isClosed = false;
+    private Thread lastReader, lastWriter;
 
-	/**
-	 * The circular buffer through which data is passed.
-	 */
-	protected byte buffer[];
-
-	/**
-	 * The index in <code>buffer</code> where the next byte will be written.
-	 */
-	protected int in = -1;
-
-	/**
-	 * The index in <code>buffer</code> where the next byte will be read.
-	 */
-	protected int out = 0;
-
-	/**
-	 * The size of the default pipe in bytes
-	 */
-	protected static final int PIPE_SIZE = 1024;
-
-	/**
-	 * Indicates if this pipe is connected
-	 */
-	boolean isConnected = false;
-
-	/**
-	 * Constructs a new unconnected PipedInputStream. The resulting Stream must
-	 * be connected to a PipedOutputStream before data may be read from it.
-	 * 
-	 */
-	public PipedInputStream() {
-		/*empty*/
-	}
-
-	/**
-	 * Constructs a new PipedInputStream connected to the PipedOutputStream
-	 * <code>out</code>. Any data written to the output stream can be read
-	 * from the this input stream.
-	 * 
-	 * @param out
-	 *            the PipedOutputStream to connect to.
-	 * 
-	 * @throws IOException
-	 *             if this or <code>out</code> are already connected.
-	 */
-	public PipedInputStream(PipedOutputStream out) throws IOException {
-		connect(out);
-	}
-
-	/**
-	 * Answers a int representing the number of bytes that are available before
-	 * this PipedInputStream will block. This method returns the number of bytes
-	 * written to the pipe but not read yet up to the size of the pipe.
-	 * 
-	 * @return int the number of bytes available before blocking.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs in this stream.
-	 */
-	@Override
+    private boolean isClosed = false;
+
+    /**
+     * The circular buffer through which data is passed.
+     */
+    protected byte buffer[];
+
+    /**
+     * The index in <code>buffer</code> where the next byte will be written.
+     */
+    protected int in = -1;
+
+    /**
+     * The index in <code>buffer</code> where the next byte will be read.
+     */
+    protected int out = 0;
+
+    /**
+     * The size of the default pipe in bytes
+     */
+    protected static final int PIPE_SIZE = 1024;
+
+    /**
+     * Indicates if this pipe is connected
+     */
+    boolean isConnected = false;
+
+    /**
+     * Constructs a new unconnected PipedInputStream. The resulting Stream must
+     * be connected to a PipedOutputStream before data may be read from it.
+     * 
+     */
+    public PipedInputStream() {
+        /* empty */
+    }
+
+    /**
+     * Constructs a new PipedInputStream connected to the PipedOutputStream
+     * <code>out</code>. Any data written to the output stream can be read
+     * from the this input stream.
+     * 
+     * @param out
+     *            the PipedOutputStream to connect to.
+     * 
+     * @throws IOException
+     *             if this or <code>out</code> are already connected.
+     */
+    public PipedInputStream(PipedOutputStream out) throws IOException {
+        connect(out);
+    }
+
+    /**
+     * Answers a int representing the number of bytes that are available before
+     * this PipedInputStream will block. This method returns the number of bytes
+     * written to the pipe but not read yet up to the size of the pipe.
+     * 
+     * @return int the number of bytes available before blocking.
+     * 
+     * @throws IOException
+     *             If an error occurs in this stream.
+     */
+    @Override
     public synchronized int available() throws IOException {
-		if (buffer == null || in == -1) {
+        if (buffer == null || in == -1) {
             return 0;
         }
-		return in <= out ? buffer.length - out + in : in - out;
-	}
+        return in <= out ? buffer.length - out + in : in - out;
+    }
 
-	/**
-	 * Close this PipedInputStream. This implementation releases the buffer used
-	 * for the pipe and notifies all threads waiting to read or write.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to close this stream.
-	 */
-	@Override
+    /**
+     * Close this PipedInputStream. This implementation releases the buffer used
+     * for the pipe and notifies all threads waiting to read or write.
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to close this stream.
+     */
+    @Override
     public void close() throws IOException {
-		synchronized (this) {
-			/* No exception thrown if already closed */
-			if (buffer != null) {
-				/* Release buffer to indicate closed. */
-				buffer = null;
-			}
-		}
-	}
-
-	/**
-	 * Connects this PipedInputStream to a PipedOutputStream. Any data written
-	 * to the OutputStream becomes readable in this InputStream.
-	 * 
-	 * @param src
-	 *            the source PipedOutputStream.
-	 * 
-	 * @throws IOException
-	 *             If either stream is already connected.
-	 */
-	public void connect(PipedOutputStream src) throws IOException {
-		src.connect(this);
-	}
-
-	/**
-	 * Reads a single byte from this PipedInputStream and returns the result as
-	 * an int. The low-order byte is returned or -1 of the end of stream was
-	 * encountered. If there is no data in the pipe, this method blocks until
-	 * there is data available. Separate threads should be used for the reader
-	 * of the PipedInputStream and the PipedOutputStream. There may be
-	 * undesirable results if more than one Thread interacts a input or output
-	 * pipe.
-	 * 
-	 * @return int The byte read or -1 if end of stream.
-	 * 
-	 * @throws IOException
-	 *             If the stream is already closed or another IOException
-	 *             occurs.
-	 */
-	@Override
+        synchronized (this) {
+            /* No exception thrown if already closed */
+            if (buffer != null) {
+                /* Release buffer to indicate closed. */
+                buffer = null;
+            }
+        }
+    }
+
+    /**
+     * Connects this PipedInputStream to a PipedOutputStream. Any data written
+     * to the OutputStream becomes readable in this InputStream.
+     * 
+     * @param src
+     *            the source PipedOutputStream.
+     * 
+     * @throws IOException
+     *             If either stream is already connected.
+     */
+    public void connect(PipedOutputStream src) throws IOException {
+        src.connect(this);
+    }
+
+    /**
+     * Reads a single byte from this PipedInputStream and returns the result as
+     * an int. The low-order byte is returned or -1 of the end of stream was
+     * encountered. If there is no data in the pipe, this method blocks until
+     * there is data available. Separate threads should be used for the reader
+     * of the PipedInputStream and the PipedOutputStream. There may be
+     * undesirable results if more than one Thread interacts a input or output
+     * pipe.
+     * 
+     * @return int The byte read or -1 if end of stream.
+     * 
+     * @throws IOException
+     *             If the stream is already closed or another IOException
+     *             occurs.
+     */
+    @Override
     public synchronized int read() throws IOException {
-		if (isConnected) {
-			if (buffer != null) {
-				/**
-				 * Set the last thread to be reading on this PipedInputStream.
-				 * If lastReader dies while someone is waiting to write an
-				 * IOException of "Pipe broken" will be thrown in receive()
-				 */
-				lastReader = Thread.currentThread();
-				try {
-					boolean first = true;
-					while (in == -1) {
-						// Are we at end of stream?
-						if (isClosed) {
-                            return -1;
-                        }
-						if (!first && lastWriter != null
-								&& !lastWriter.isAlive()) {
-                            throw new IOException(org.apache.harmony.luni.util.Msg
-									.getString("K0076")); //$NON-NLS-1$
-                        }
-						first = false;
-						// Notify callers of receive()
-						notifyAll();
-						wait(1000);
-					}
-				} catch (InterruptedException e) {
-					throw new InterruptedIOException();
-				}
-
-				byte result = buffer[out++];
-				if (out == buffer.length) {
-                    out = 0;
+        if (!isConnected) {
+            throw new IOException(Msg.getString("K0074")); //$NON-NLS-1$
+        }
+        if (buffer == null) {
+            throw new IOException(Msg.getString("K0075")); //$NON-NLS-1$
+        }
+        /**
+         * Set the last thread to be reading on this PipedInputStream. If
+         * lastReader dies while someone is waiting to write an IOException of
+         * "Pipe broken" will be thrown in receive()
+         */
+        lastReader = Thread.currentThread();
+        try {
+            boolean first = true;
+            while (in == -1) {
+                // Are we at end of stream?
+                if (isClosed) {
+                    return -1;
                 }
-				if (out == in) {
-					// empty buffer
-					in = -1;
-					out = 0;
-				}
-				return result & 0xff;
-			}
-			throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0075")); //$NON-NLS-1$
-		}
-		throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0074")); //$NON-NLS-1$
-	}
-
-	/**
-	 * Reads at most <code>count</code> bytes from this PipedInputStream and
-	 * stores them in byte array <code>buffer</code> starting at
-	 * <code>offset</code>. Answer the number of bytes actually read or -1 if
-	 * no bytes were read and end of stream was encountered. Separate threads
-	 * should be used for the reader of the PipedInputStream and the
-	 * PipedOutputStream. There may be undesirable results if more than one
-	 * Thread interacts a input or output pipe.
-	 * 
-	 * @param bytes
-	 *            the byte array in which to store the read bytes.
-	 * @param offset
-	 *            the offset in <code>buffer</code> to store the read bytes.
-	 * @param count
-	 *            the maximum number of bytes to store in <code>buffer</code>.
-	 * @return the number of bytes actually read or -1 if end of stream.
-	 * 
-	 * @throws IOException
-	 *             If the stream is already closed or another IOException
-	 *             occurs.
-	 */
-	@Override
-    public synchronized int read(byte[] bytes, int offset, int count)
-			throws IOException {
-		if (bytes != null && 0 <= offset && offset <= bytes.length
-				&& 0 <= count && count <= bytes.length - offset) {
-			if (count == 0) {
-                return 0;
+                if (!first && lastWriter != null && !lastWriter.isAlive()) {
+                    throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
+                }
+                first = false;
+                // Notify callers of receive()
+                notifyAll();
+                wait(1000);
             }
-			if (isConnected && buffer != null) {
-				/**
-				 * Set the last thread to be reading on this PipedInputStream.
-				 * If lastReader dies while someone is waiting to write an
-				 * IOException of "Pipe broken" will be thrown in receive()
-				 */
-				lastReader = Thread.currentThread();
-				try {
-					boolean first = true;
-					while (in == -1) {
-						// Are we at end of stream?
-						if (isClosed) {
-                            return -1;
-                        }
-						if (!first && lastWriter != null
-								&& !lastWriter.isAlive()) {
-                            throw new IOException(org.apache.harmony.luni.util.Msg
-									.getString("K0076")); //$NON-NLS-1$
-                        }
-						first = false;
-						// Notify callers of receive()
-						notifyAll();
-						wait(1000);
-					}
-				} catch (InterruptedException e) {
-					throw new InterruptedIOException();
-				}
-
-				int copyLength = 0;
-				/* Copy bytes from out to end of buffer first */
-				if (out >= in) {
-					copyLength = count > (buffer.length - out) ? buffer.length
-							- out : count;
-					System.arraycopy(buffer, out, bytes, offset, copyLength);
-					out += copyLength;
-					if (out == buffer.length) {
-                        out = 0;
-                    }
-					if (out == in) {
-						// empty buffer
-						in = -1;
-						out = 0;
-					}
-				}
-
-				/*
-				 * Did the read fully succeed in the previous copy or is the
-				 * buffer empty?
-				 */
-				if (copyLength == count || in == -1) {
-                    return copyLength;
+        } catch (InterruptedException e) {
+            throw new InterruptedIOException();
+        }
+
+        byte result = buffer[out++];
+        if (out == buffer.length) {
+            out = 0;
+        }
+        if (out == in) {
+            // empty buffer
+            in = -1;
+            out = 0;
+        }
+        return result & 0xff;
+    }
+
+    /**
+     * Reads at most <code>count</code> bytes from this PipedInputStream and
+     * stores them in byte array <code>buffer</code> starting at
+     * <code>offset</code>. Answer the number of bytes actually read or -1 if
+     * no bytes were read and end of stream was encountered. Separate threads
+     * should be used for the reader of the PipedInputStream and the
+     * PipedOutputStream. There may be undesirable results if more than one
+     * Thread interacts a input or output pipe.
+     * 
+     * @param bytes
+     *            the byte array in which to store the read bytes.
+     * @param offset
+     *            the offset in <code>buffer</code> to store the read bytes.
+     * @param count
+     *            the maximum number of bytes to store in <code>buffer</code>.
+     * @return the number of bytes actually read or -1 if end of stream.
+     * 
+     * @throws IOException
+     *             If the stream is already closed or another IOException
+     *             occurs.
+     */
+    @Override
+    public synchronized int read(byte[] bytes, int offset, int count)
+            throws IOException {
+        if (bytes == null) {
+            throw new NullPointerException();
+        }
+
+        if (offset < 0 || offset > bytes.length || count < 0
+                || count > bytes.length - offset) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        if (count == 0) {
+            return 0;
+        }
+
+        if (!isConnected) {
+            throw new IOException(Msg.getString("K0074")); //$NON-NLS-1$
+        }
+
+        if (buffer == null) {
+            throw new IOException(Msg.getString("K0075")); //$NON-NLS-1$
+        }
+
+        /**
+         * Set the last thread to be reading on this PipedInputStream. If
+         * lastReader dies while someone is waiting to write an IOException of
+         * "Pipe broken" will be thrown in receive()
+         */
+        lastReader = Thread.currentThread();
+        try {
+            boolean first = true;
+            while (in == -1) {
+                // Are we at end of stream?
+                if (isClosed) {
+                    return -1;
+                }
+                if (!first && lastWriter != null && !lastWriter.isAlive()) {
+                    throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
                 }
+                first = false;
+                // Notify callers of receive()
+                notifyAll();
+                wait(1000);
+            }
+        } catch (InterruptedException e) {
+            throw new InterruptedIOException();
+        }
+
+        int copyLength = 0;
+        /* Copy bytes from out to end of buffer first */
+        if (out >= in) {
+            copyLength = count > (buffer.length - out) ? buffer.length - out
+                    : count;
+            System.arraycopy(buffer, out, bytes, offset, copyLength);
+            out += copyLength;
+            if (out == buffer.length) {
+                out = 0;
+            }
+            if (out == in) {
+                // empty buffer
+                in = -1;
+                out = 0;
+            }
+        }
+
+        /*
+         * Did the read fully succeed in the previous copy or is the buffer
+         * empty?
+         */
+        if (copyLength == count || in == -1) {
+            return copyLength;
+        }
+
+        int bytesCopied = copyLength;
+        /* Copy bytes from 0 to the number of available bytes */
+        copyLength = in - out > (count - bytesCopied) ? count - bytesCopied
+                : in - out;
+        System.arraycopy(buffer, out, bytes, offset + bytesCopied, copyLength);
+        out += copyLength;
+        if (out == in) {
+            // empty buffer
+            in = -1;
+            out = 0;
+        }
+        return bytesCopied + copyLength;
+    }
 
-				int bytesCopied = copyLength;
-				/* Copy bytes from 0 to the number of available bytes */
-				copyLength = in - out > (count - bytesCopied) ? count
-						- bytesCopied : in - out;
-				System.arraycopy(buffer, out, bytes, offset + bytesCopied,
-						copyLength);
-				out += copyLength;
-				if (out == in) {
-					// empty buffer
-					in = -1;
-					out = 0;
-				}
-				return bytesCopied + copyLength;
-			}
-			if (!isConnected) {
-				throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0074")); //$NON-NLS-1$
-			}
-			throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0075")); //$NON-NLS-1$
-		}
-		if (bytes == null) {
-			throw new NullPointerException();
-		}
-		throw new IndexOutOfBoundsException();
-	}
-
-	/**
-	 * Receives a byte and stores it into the PipedInputStream. This called by
-	 * PipedOutputStream.write() when writes occur. The lowest-order byte is
-	 * stored at index <code>in</code> in the <code>buffer</code>.
-	 * <P>
-	 * If the buffer is full and the thread sending #receive is interrupted, the
-	 * InterruptedIOException will be thrown.
-	 * 
-	 * @param oneByte
-	 *            the byte to store into the pipe.
-	 * 
-	 * @throws IOException
-	 *             If the stream is already closed or another IOException
-	 *             occurs.
-	 */
-	protected synchronized void receive(int oneByte) throws IOException {
-		if (buffer == null || isClosed) {
-		    throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0078")); //$NON-NLS-1$
-        }
-        if (lastReader != null && !lastReader.isAlive()){
-            throw new IOException(org.apache.harmony.luni.util.Msg.getString("K0076")); //$NON-NLS-1$
-        }
-		/**
-		 * Set the last thread to be writing on this PipedInputStream. If
-		 * lastWriter dies while someone is waiting to read an IOException
-		 * of "Pipe broken" will be thrown in read()
-		 */
-		lastWriter = Thread.currentThread();
-		try {
-			while (buffer != null && out == in) {
-				notifyAll();
-				wait(1000);
-				if (lastReader != null && !lastReader.isAlive()) {
-                    throw new IOException(org.apache.harmony.luni.util.Msg
-							.getString("K0076")); //$NON-NLS-1$
+    /**
+     * Receives a byte and stores it into the PipedInputStream. This called by
+     * PipedOutputStream.write() when writes occur. The lowest-order byte is
+     * stored at index <code>in</code> in the <code>buffer</code>.
+     * <P>
+     * If the buffer is full and the thread sending #receive is interrupted, the
+     * InterruptedIOException will be thrown.
+     * 
+     * @param oneByte
+     *            the byte to store into the pipe.
+     * 
+     * @throws IOException
+     *             If the stream is already closed or another IOException
+     *             occurs.
+     */
+    protected synchronized void receive(int oneByte) throws IOException {
+        if (buffer == null || isClosed) {
+            throw new IOException(Msg.getString("K0078")); //$NON-NLS-1$
+        }
+        if (lastReader != null && !lastReader.isAlive()) {
+            throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
+        }
+        /**
+         * Set the last thread to be writing on this PipedInputStream. If
+         * lastWriter dies while someone is waiting to read an IOException of
+         * "Pipe broken" will be thrown in read()
+         */
+        lastWriter = Thread.currentThread();
+        try {
+            while (buffer != null && out == in) {
+                notifyAll();
+                wait(1000);
+                if (lastReader != null && !lastReader.isAlive()) {
+                    throw new IOException(Msg.getString("K0076")); //$NON-NLS-1$
                 }
-			}
-		} catch (InterruptedException e) {
-			throw new InterruptedIOException();
-		}
-		if (buffer != null) {
-			if (in == -1) {
+            }
+        } catch (InterruptedException e) {
+            throw new InterruptedIOException();
+        }
+        if (buffer != null) {
+            if (in == -1) {
                 in = 0;
             }
-			buffer[in++] = (byte) oneByte;
-			if (in == buffer.length) {
+            buffer[in++] = (byte) oneByte;
+            if (in == buffer.length) {
                 in = 0;
             }
-			return;
-		}
-	}
-
-	synchronized void done() {
-		isClosed = true;
-		notifyAll();
-	}
+            return;
+        }
+    }
 
+    synchronized void done() {
+        isClosed = true;
+        notifyAll();
+    }
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedOutputStream.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedOutputStream.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedOutputStream.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedOutputStream.java Thu Jan  4 09:47:01 2007
@@ -68,7 +68,8 @@
      */
     @Override
     public void close() throws IOException {
-        if (dest != null) { // Is the pipe connected?
+        // Is the pipe connected?
+        if (dest != null) {
             dest.done();
             dest = null;
         }
@@ -88,19 +89,17 @@
         if (null == stream) {
             throw new NullPointerException();
         }
-        if (this.dest == null) {
-            synchronized (stream) {
-                if (!stream.isConnected) {
-                    stream.buffer = new byte[PipedInputStream.PIPE_SIZE];
-                    stream.isConnected = true;
-                    this.dest = stream;
-                } else {
-                    throw new IOException(Msg.getString("K007a")); //$NON-NLS-1$
-                }
-            }
-        } else {
+        if (this.dest != null) {
             throw new IOException(Msg.getString("K0079")); //$NON-NLS-1$
         }
+        synchronized (stream) {
+            if (stream.isConnected) {
+                throw new IOException(Msg.getString("K007a")); //$NON-NLS-1$
+            }
+            stream.buffer = new byte[PipedInputStream.PIPE_SIZE];
+            stream.isConnected = true;
+            this.dest = stream;
+        }
     }
 
     /**
@@ -178,10 +177,9 @@
      */
     @Override
     public void write(int oneByte) throws IOException {
-        if (dest != null) {
-            dest.receive(oneByte);
-        } else {
+        if (dest == null) {
             throw new IOException(Msg.getString("K007b")); //$NON-NLS-1$
         }
+        dest.receive(oneByte);
     }
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedReader.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedReader.java?view=diff&rev=492652&r1=492651&r2=492652
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedReader.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/io/PipedReader.java Thu Jan  4 09:47:01 2007
@@ -19,168 +19,166 @@
 
 import org.apache.harmony.luni.util.Msg;
 
-
 /**
  * PipedReader is a class which receives information on a communications pipe.
  * When two threads want to pass data back and forth, one creates a piped writer
  * and the other creates a piped reader.
- * 
  */
 public class PipedReader extends Reader {
-	private Thread lastReader;
-    
+
+    private Thread lastReader;
+
     private Thread lastWriter;
 
-	private boolean isClosed;
+    private boolean isClosed;
+
+    /**
+     * The circular buffer through which data is passed.
+     */
+    private char data[];
+
+    /**
+     * The index in <code>buffer</code> where the next character will be
+     * written.
+     */
+    private int in = -1;
+
+    /**
+     * The index in <code>buffer</code> where the next character will be read.
+     */
+    private int out;
+
+    /**
+     * The size of the default pipe in characters
+     */
+    private static final int PIPE_SIZE = 1024;
+
+    /**
+     * Indicates if this pipe is connected
+     */
+    private boolean isConnected;
+
+    /**
+     * Constructs a new unconnected PipedReader. The resulting Reader must be
+     * connected to a PipedWriter before data may be read from it.
+     */
+    public PipedReader() {
+        data = new char[PIPE_SIZE];
+    }
+
+    /**
+     * Constructs a new PipedReader connected to the PipedWriter
+     * <code>out</code>. Any data written to the writer can be read from the
+     * this reader.
+     * 
+     * @param out
+     *            the PipedWriter to connect to.
+     * 
+     * @throws IOException
+     *             if this or <code>out</code> are already connected.
+     */
+    public PipedReader(PipedWriter out) throws IOException {
+        this();
+        connect(out);
+    }
 
-	/**
-	 * The circular buffer through which data is passed.
-	 */
-	private char data[];
-
-	/**
-	 * The index in <code>buffer</code> where the next character will be
-	 * written.
-	 */
-	private int in = -1;
-
-	/**
-	 * The index in <code>buffer</code> where the next character will be read.
-	 */
-	private int out;
-
-	/**
-	 * The size of the default pipe in characters
-	 */
-	private static final int PIPE_SIZE = 1024;
-
-	/**
-	 * Indicates if this pipe is connected
-	 */
-	private boolean isConnected;
-
-	/**
-	 * Constructs a new unconnected PipedReader. The resulting Reader must be
-	 * connected to a PipedWriter before data may be read from it.
-	 */
-	public PipedReader() {
-		data = new char[PIPE_SIZE];
-	}
-
-	/**
-	 * Constructs a new PipedReader connected to the PipedWriter
-	 * <code>out</code>. Any data written to the writer can be read from the
-	 * this reader.
-	 * 
-	 * @param out
-	 *            the PipedWriter to connect to.
-	 * 
-	 * @throws IOException
-	 *             if this or <code>out</code> are already connected.
-	 */
-	public PipedReader(PipedWriter out) throws IOException {
-		this();
-		connect(out);
-	}
-
-	/**
-	 * Close this PipedReader. This implementation releases the buffer used for
-	 * the pipe and notifies all threads waiting to read or write.
-	 * 
-	 * @throws IOException
-	 *             If an error occurs attempting to close this reader.
-	 */
-	@Override
+    /**
+     * Close this PipedReader. This implementation releases the buffer used for
+     * the pipe and notifies all threads waiting to read or write.
+     * 
+     * @throws IOException
+     *             If an error occurs attempting to close this reader.
+     */
+    @Override
     public void close() throws IOException {
-		synchronized (lock) {
-			/* No exception thrown if already closed */
-			if (data != null) {
-				/* Release buffer to indicate closed. */
-				data = null;
-			}
-		}
-	}
-
-	/**
-	 * Connects this PipedReader to a PipedWriter. Any data written to the
-	 * Writer becomes available in this Reader.
-	 * 
-	 * @param src
-	 *            the source PipedWriter.
-	 * 
-	 * @throws IOException
-	 *             If either Writer or Reader is already connected.
-	 */
-	public void connect(PipedWriter src) throws IOException {
-		synchronized (lock) {
-			src.connect(this);
-		}
-	}
-
-	/**
-	 * Establish the connection to the PipedWriter.
-	 * 
-	 * @throws IOException
-	 *             If this Reader is already connected.
-	 */
-	void establishConnection() throws IOException {
-		synchronized (lock) {
-			if (data == null) {
+        synchronized (lock) {
+            /* No exception thrown if already closed */
+            if (data != null) {
+                /* Release buffer to indicate closed. */
+                data = null;
+            }
+        }
+    }
+
+    /**
+     * Connects this PipedReader to a PipedWriter. Any data written to the
+     * Writer becomes available in this Reader.
+     * 
+     * @param src
+     *            the source PipedWriter.
+     * 
+     * @throws IOException
+     *             If either Writer or Reader is already connected.
+     */
+    public void connect(PipedWriter src) throws IOException {
+        synchronized (lock) {
+            src.connect(this);
+        }
+    }
+
+    /**
+     * Establish the connection to the PipedWriter.
+     * 
+     * @throws IOException
+     *             If this Reader is already connected.
+     */
+    void establishConnection() throws IOException {
+        synchronized (lock) {
+            if (data == null) {
                 throw new IOException(Msg.getString("K0078")); //$NON-NLS-1$
             }
-			if (!isConnected) {
-				isConnected = true;
-			} else {
+            if (isConnected) {
                 throw new IOException(Msg.getString("K007a")); //$NON-NLS-1$
             }
-		}
-	}
+            isConnected = true;
+        }
+    }
 
-	/**
-	 * Reads the next character from this Reader. Answer the character actually
-	 * read or -1 if no character was read and end of reader was encountered.
-	 * Separate threads should be used for the reader of the PipedReader and the
-	 * PipedWriter. There may be undesirable results if more than one Thread
-	 * interacts a reader or writer pipe.
-	 * 
-	 * @return int the character read -1 if end of reader.
-	 * 
-	 * @throws IOException
-	 *             If the reader is already closed or another IOException
-	 *             occurs.
-	 */
-	@Override
+    /**
+     * Reads the next character from this Reader. Answer the character actually
+     * read or -1 if no character was read and end of reader was encountered.
+     * Separate threads should be used for the reader of the PipedReader and the
+     * PipedWriter. There may be undesirable results if more than one Thread
+     * interacts a reader or writer pipe.
+     * 
+     * @return int the character read -1 if end of reader.
+     * 
+     * @throws IOException
+     *             If the reader is already closed or another IOException
+     *             occurs.
+     */
+    @Override
     public int read() throws IOException {
-		char[] carray = new char[1];
-		int result = read(carray, 0, 1);
-		return result != -1 ? carray[0] : result;
-	}
-
-	/**
-	 * Reads at most <code>count</code> character from this PipedReader and
-	 * stores them in char array <code>buffer</code> starting at
-	 * <code>offset</code>. Answer the number of characters actually read or
-	 * -1 if no characters were read and end of stream was encountered. Separate
-	 * threads should be used for the reader of the PipedReader and the
-	 * PipedWriter. There may be undesirable results if more than one Thread
-	 * interacts a reader or writer pipe.
-	 * 
-	 * @param buffer
-	 *            the character array in which to store the read characters.
-	 * @param offset
-	 *            the offset in <code>buffer</code> to store the read
-	 *            characters.
-	 * @param count
-	 *            the maximum number of characters to store in
-	 *            <code>buffer</code>.
-	 * @return int the number of characters actually read or -1 if end of
-	 *         reader.
-	 * 
-	 * @throws IOException
-	 *             If the reader is already closed or another IOException
-	 *             occurs.
-	 */
-	@Override
+        char[] carray = new char[1];
+        int result = read(carray, 0, 1);
+        return result != -1 ? carray[0] : result;
+    }
+
+    /**
+     * Reads at most <code>count</code> character from this PipedReader and
+     * stores them in char array <code>buffer</code> starting at
+     * <code>offset</code>. Answer the number of characters actually read or
+     * -1 if no characters were read and end of stream was encountered. Separate
+     * threads should be used for the reader of the PipedReader and the
+     * PipedWriter. There may be undesirable results if more than one Thread
+     * interacts a reader or writer pipe.
+     * 
+     * @param buffer
+     *            the character array in which to store the read characters.
+     * @param offset
+     *            the offset in <code>buffer</code> to store the read
+     *            characters.
+     * @param count
+     *            the maximum number of characters to store in
+     *            <code>buffer</code>.
+     * @return int the number of characters actually read or -1 if end of
+     *         reader.
+     * 
+     * @throws IOException
+     *             If the reader is already closed or another IOException
+     *             occurs.
+     */
+    @Override
     public int read(char[] buffer, int offset, int count) throws IOException {
         synchronized (lock) {
             if (!isConnected) {
@@ -224,7 +222,8 @@
             int copyLength = 0;
             /* Copy chars from out to end of buffer first */
             if (out >= in) {
-                copyLength = count > data.length - out ? data.length - out : count;
+                copyLength = count > data.length - out ? data.length - out
+                        : count;
                 System.arraycopy(data, out, buffer, offset, copyLength);
                 out += copyLength;
                 if (out == data.length) {
@@ -247,7 +246,8 @@
 
             int charsCopied = copyLength;
             /* Copy bytes from 0 to the number of available bytes */
-            copyLength = in - out > count - copyLength ? count - copyLength : in - out;
+            copyLength = in - out > count - copyLength ? count - copyLength
+                    : in - out;
             System.arraycopy(data, out, buffer, offset + charsCopied,
                     copyLength);
             out += copyLength;
@@ -260,43 +260,45 @@
         }
     }
 
-	/**
-	 * Answer a boolean indicating whether or not this Reader is ready to be
-	 * read. Answers true if the buffer contains characters to be read.
-	 * 
-	 * @return boolean <code>true</code> if there are characters ready,
-	 *         <code>false</code> otherwise.
-	 *
-	 * @throws 		IOException If the reader is already closed or another IOException occurs.
-	 */
-	@Override
+    /**
+     * Answer a boolean indicating whether or not this Reader is ready to be
+     * read. Answers true if the buffer contains characters to be read.
+     * 
+     * @return boolean <code>true</code> if there are characters ready,
+     *         <code>false</code> otherwise.
+     * 
+     * @throws IOException
+     *             If the reader is already closed or another IOException
+     *             occurs.
+     */
+    @Override
     public boolean ready() throws IOException {
         synchronized (lock) {
-            if (isConnected) {
-                if (data != null) {
-                    return in != -1;
-                }
+            if (!isConnected) {
+                throw new IOException(Msg.getString("K007b")); //$NON-NLS-1$
+            }
+            if (data == null) {
                 throw new IOException(Msg.getString("K0078")); //$NON-NLS-1$
             }
-            throw new IOException(Msg.getString("K007b")); //$NON-NLS-1$
+            return in != -1;
         }
     }
 
-	/**
-	 * Receives a char and stores it into the PipedReader. This called by
-	 * PipedWriter.write() when writes occur.
-	 * <P>
-	 * If the buffer is full and the thread sending #receive is interrupted, the
-	 * InterruptedIOException will be thrown.
-	 * 
-	 * @param oneChar
-	 *            the char to store into the pipe.
-	 * 
-	 * @throws IOException
-	 *             If the stream is already closed or another IOException
-	 *             occurs.
-	 */
-	void receive(char oneChar) throws IOException {
+    /**
+     * Receives a char and stores it into the PipedReader. This called by
+     * PipedWriter.write() when writes occur.
+     * <P>
+     * If the buffer is full and the thread sending #receive is interrupted, the
+     * InterruptedIOException will be thrown.
+     * 
+     * @param oneChar
+     *            the char to store into the pipe.
+     * 
+     * @throws IOException
+     *             If the stream is already closed or another IOException
+     *             occurs.
+     */
+    void receive(char oneChar) throws IOException {
         synchronized (lock) {
             if (data == null) {
                 throw new IOException(Msg.getString("K0078")); //$NON-NLS-1$
@@ -334,25 +336,25 @@
         }
     }
 
-	/**
-	 * Receives a char array and stores it into the PipedReader. This called by
-	 * PipedWriter.write() when writes occur.
-	 * <P>
-	 * If the buffer is full and the thread sending #receive is interrupted, the
-	 * InterruptedIOException will be thrown.
-	 * 
-	 * @param chars
-	 *            the char array to store into the pipe.
-	 * @param offset
-	 *            offset to start reading from
-	 * @param count
-	 *            total characters to read
-	 * 
-	 * @throws IOException
-	 *             If the stream is already closed or another IOException
-	 *             occurs.
-	 */
-	void receive(char[] chars, int offset, int count) throws IOException {
+    /**
+     * Receives a char array and stores it into the PipedReader. This called by
+     * PipedWriter.write() when writes occur.
+     * <P>
+     * If the buffer is full and the thread sending #receive is interrupted, the
+     * InterruptedIOException will be thrown.
+     * 
+     * @param chars
+     *            the char array to store into the pipe.
+     * @param offset
+     *            offset to start reading from
+     * @param count
+     *            total characters to read
+     * 
+     * @throws IOException
+     *             If the stream is already closed or another IOException
+     *             occurs.
+     */
+    void receive(char[] chars, int offset, int count) throws IOException {
         synchronized (lock) {
             if (data == null) {
                 throw new IOException(Msg.getString("K0078")); //$NON-NLS-1$
@@ -414,16 +416,16 @@
         }
     }
 
-	void done() {
-		synchronized (lock) {
-			isClosed = true;
-			lock.notifyAll();
-		}
-	}
-
-	void flush() {
-		synchronized (lock) {
-			lock.notifyAll();
-		}
-	}
+    void done() {
+        synchronized (lock) {
+            isClosed = true;
+            lock.notifyAll();
+        }
+    }
+
+    void flush() {
+        synchronized (lock) {
+            lock.notifyAll();
+        }
+    }
 }



Mime
View raw message