AbstractMethodError.java: Re-merged with Classpath.

	* java/lang/AbstractMethodError.java: Re-merged with Classpath.
	* java/lang/ArithmeticException.java: Likewise.
	* java/lang/ArrayIndexOutOfBoundsException.java: Likewise.
	* java/lang/ArrayStoreException.java: Likewise.
	* java/lang/Byte.java: Likewise.
	* java/lang/CharSequence.java: Likewise.
	* java/lang/ClassCastException.java: Likewise.
	* java/lang/ClassCircularityError.java: Likewise.
	* java/lang/ClassFormatError.java: Likewise.
	* java/lang/CloneNotSupportedException.java: Likewise.
	* java/lang/Cloneable.java: Likewise.
	* java/lang/Comparable.java: Likewise.
	* java/lang/Compiler.java: Likewise.
	* java/lang/Error.java: Likewise.
	* java/lang/ExceptionInInitializerError.java: Likewise.
	* java/lang/IllegalAccessError.java: Likewise.
	* java/lang/IllegalAccessException.java: Likewise.
	* java/lang/IllegalArgumentException.java: Likewise.
	* java/lang/IllegalMonitorStateException.java: Likewise.
	* java/lang/IllegalStateException.java: Likewise.
	* java/lang/IllegalThreadStateException.java: Likewise.
	* java/lang/IncompatibleClassChangeError.java: Likewise.
	* java/lang/IndexOutOfBoundsException.java: Likewise.
	* java/lang/InheritableThreadLocal.java: Likewise.
	* java/lang/InstantiationError.java: Likewise.
	* java/lang/InstantiationException.java: Likewise.
	* java/lang/InternalError.java: Likewise.
	* java/lang/InterruptedException.java: Likewise.
	* java/lang/LinkageError.java: Likewise.
	* java/lang/NegativeArraySizeException.java: Likewise.
	* java/lang/NoClassDefFoundError.java: Likewise.
	* java/lang/NoSuchFieldError.java: Likewise.
	* java/lang/NoSuchFieldException.java: Likewise.
	* java/lang/NoSuchMethodError.java: Likewise.
	* java/lang/NoSuchMethodException.java: Likewise.
	* java/lang/NullPointerException.java: Likewise.
	* java/lang/NumberFormatException.java: Likewise.
	* java/lang/OutOfMemoryError.java: Likewise.
	* java/lang/Process.java: Likewise.
	* java/lang/Runnable.java: Likewise.
	* java/lang/RuntimePermission.java: Likewise.
	* java/lang/SecurityException.java: Likewise.
	* java/lang/Short.java: Likewise.
	* java/lang/StackOverflowError.java: Likewise.
	* java/lang/StringIndexOutOfBoundsException.java: Likewise.
	* java/lang/ThreadDeath.java: Likewise.
	* java/lang/ThreadLocal.java: Likewise.
	* java/lang/UnknownError.java: Likewise.
	* java/lang/UnsatisfiedLinkError.java: Likewise.
	* java/lang/UnsupportedClassVersionError.java: Likewise.
	* java/lang/UnsupportedOperationException.java: Likewise.
	* java/lang/VerifyError.java: Likewise.
	* java/lang/VirtualMachineError.java: Likewise.
	* java/lang/reflect/InvocationTargetException.java: Likewise.
	* java/net/BindException.java: Likewise.
	* java/net/ConnectException.java: Likewise.
	* java/net/MalformedURLException.java: Likewise.
	* java/net/NoRouteToHostException.java: Likewise.
	* java/net/ProtocolException.java: Likewise.
	* java/net/SocketException.java: Likewise.
	* java/net/UnknownHostException.java: Likewise.
	* java/net/UnknownServiceException.java: Likewise.

From-SVN: r54656

1 files changed, 100 insertions, 114 deletions

diff --git a/libjava/java/lang/ThreadLocal.java b/libjava/java/lang/ThreadLocal.java
index f671d4e..b5877f5 100644
--- a/libjava/java/lang/ThreadLocal.java
+++ b/libjava/java/lang/ThreadLocal.java
@@ -1,5 +1,5 @@
-/* java.lang.ThreadLocal
-   Copyright (C) 2000 Free Software Foundation, Inc.
+/* ThreadLocal -- a variable with a unique value per thread
+   Copyright (C) 2000, 2002 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
- 
+
 GNU Classpath is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ -46,131 +46,117 @@ import java.util.WeakHashMap;
  * (through the <code>get()</code> and <code>set()</code> methods)
  * only affects the state of the object as seen by the currently
  * executing Thread.
- * <p>
- * The first time a ThreadLocal object is accessed on a particular
- * Thread (and no state is associated with that Thread yet)
- * the state for that Thread is set by executing the method
- * <code>initialValue()</code>.
- * <p>
- * An example how you can use this:
+ *
+ * <p>The first time a ThreadLocal object is accessed on a particular
+ * Thread, the state for that Thread's copy of the local variable is set by
+ * executing the method <code>initialValue()</code>.
+ *
+ * <p>An example how you can use this:
  * <pre>
- * class Connection {
- *     private static ThreadLocal owner = new ThreadLocal() {
- *        public Object initialValue() {
- *            return("nobody");
- *        }
+ * class Connection
+ * {
+ *   private static ThreadLocal owner = new ThreadLocal()
+ *     {
+ *       public Object initialValue()
+ *       {
+ *         return("nobody");
+ *       }
  *     };
  * ...
  * }
- * </pre>
+ * </pre></br>
+ *
  * Now all instances of connection can see who the owner of the currently
  * executing Thread is by calling <code>owner.get()</code>. By default any
  * Thread would be associated with 'nobody'. But the Connection object could
  * offer a method that changes the owner associated with the Thread on
  * which the method was called by calling <code>owner.put("somebody")</code>.
  * (Such an owner changing method should then be guarded by security checks.)
- * <p>
- * When a Thread is garbage collected all references to values of
+ *
+ * <p>When a Thread is garbage collected all references to values of
  * the ThreadLocal objects associated with that Thread are removed.
  *
+ * @author Mark Wielaard <mark@klomp.org>
+ * @author Eric Blake <ebb9@email.byu.edu>
  * @since 1.2
- * @author Mark Wielaard (mark@klomp.org)
+ * @status updated to 1.4
  */
-public class ThreadLocal {
-	
-	/**
-	 * Trivial container to wrap the stored values.
-	 * Needed to see if the value is null or not yet set.
-	 * If it is not yet set we must call intialValue() once.
-	 * Package local so InheritableThreadLocal can see it.
-	 */
-	final static class Value {
-		final Object value;
-		
-		Value(Object value) {
-			this.value = value;
-		}
-		
-		Object getValue() {
-			return value;
-		}
-	}
-	
-	/**
-	 * Maps Threads to Values. Uses a WeakHashMap so if a Thread is garbage
-	 * collected the reference to the Value will disappear. Only the
-	 * <code>set(Thread, Value)</code> and <code>get(Thread)</code> methods
-	 * access it. Since this can happen from multiple Threads simultaniously
-	 * those methods are synchronized.
-	 */
-	private final Map valueMap = new WeakHashMap();
-	
-	/**
-	 * Creates a ThreadLocal object without associating any value to it
-	 * yet.
-	 */
-	public ThreadLocal() {
-	}
-	
-	/**
-	 * Gets the value associated with the ThreadLocal object for the
-	 * currently executing Thread. If there is no value is associated
-	 * with this Thread yet then the valued returned by the
-	 * <code>initialValue()</code> method is assosiated with this Thread
-	 * and returned.
-	 */
-	public Object get() {
-		Thread currentThread = Thread.currentThread();
-		Value v = get(currentThread);
-		if (v == null) {
-			v = new Value(initialValue());
-			set(currentThread, v);
-		}
-		return v.getValue();
-	}
-	
-	/**
-	 * Gets the Value of this ThreadLocal for a particular Thread.
-	 * It is synchronized so the <code>set(Thread, Value)</code> method cannot
-	 * simultaniously modify the </code>valueMap</code> from another thread.
-	 * Package local so InheritableThreadLocal can access it when a new child
-	 * Thread inherits values from its parent Thread.
-	 */
-	synchronized final Value get(Thread thread) {
-		return (Value)valueMap.get(thread);
-	}
-	
-	/**
-	 * Sets the value associated with the ThreadLocal object for the
-	 * currently executing Thread. This overrides any existing value
-	 * associated with the current Thread and does not call the
-	 * <code>initialValue()</code> method, even if this is the first
-	 * time this Thread accesses this ThreadLocal.
-	 */
-	public void set(Object value) {
-		Thread currentThread = Thread.currentThread();
-		Value v = new Value(value);
-		set(currentThread, v);
-	}
+public class ThreadLocal
+{
+  /**
+   * Placeholder to distinguish between uninitialized and null set by the
+   * user. Do not expose this to the public. Package visible for use by
+   * InheritableThreadLocal
+   */
+  static final Object NULL = new Object();
+
+  /**
+   * The stored value. Package visible for use by InheritableThreadLocal. */
+  Object value;
 	
-	/**
-	 * Sets the Value for this ThreadLocal for a particular Thread.
-	 * It is synchronized so the <code>get(Thread)</code> method cannot
-	 * simultaniously read the </code>valueMap</code> from another thread.
-	 * Package local so InheritableThreadLocal can access it when a new child
-	 * Thread inherits values from its parent Thread.
-	 */
-	synchronized final void set(Thread thread, Value value) {
-		valueMap.put(thread, value);
-	}
+  /**
+   * Maps Threads to values. Uses a WeakHashMap so if a Thread is garbage
+   * collected the reference to the Value will disappear. A null value means
+   * uninitialized, while NULL means a user-specified null. Only the
+   * <code>set(Thread, Object)</code> and <code>get(Thread)</code> methods
+   * access it. Package visible for use by InheritableThreadLocal.
+   */
+  final Map valueMap = new WeakHashMap();
 	
-	/**
-	 * Called when <code>get()</code> is called and no state is associated
-	 * with the currently executing Thread yet.
-	 * <p>
-	 * The default implementation returns <code>null</code>.
-	 */
-	protected Object initialValue() {
-		return null;
-	}
+  /**
+   * Creates a ThreadLocal object without associating any value to it yet.
+   */
+  public ThreadLocal()
+  {
+  }
+
+  /**
+   * Called once per thread on the first invocation of get(), if set() was
+   * not already called. The default implementation returns <code>null</code>.
+   * Often, this method is overridden to create the appropriate initial object
+   * for the current thread's view of the ThreadLocal.
+   *
+   * @return the initial value of the variable in this thread
+   */
+  protected Object initialValue()
+  {
+    return null;
+  }
+
+  /**
+   * Gets the value associated with the ThreadLocal object for the currently
+   * executing Thread. If this is the first time the current thread has called
+   * get(), and it has not already called set(), the value is obtained by
+   * <code>initialValue()</code>.
+   *
+   * @return the value of the variable in this thread
+   */
+  public Object get()
+  {
+    Thread currentThread = Thread.currentThread();
+    // Note that we don't have to synchronize, as only this thread will
+    // ever modify the returned value.
+    Object value = valueMap.get(currentThread);
+    if (value == null)
+      {
+        value = initialValue();
+        valueMap.put(currentThread, value == null ? NULL : value);
+      }
+    return value == NULL ? null : value;
+  }
+
+  /**
+   * Sets the value associated with the ThreadLocal object for the currently
+   * executing Thread. This overrides any existing value associated with the
+   * current Thread and prevents <code>initialValue()</code> from being
+   * called if this is the first access to this ThreadLocal in this Thread.
+   *
+   * @param value the value to set this thread's view of the variable to
+   */
+  public void set(Object value)
+  {
+    // Note that we don't have to synchronize, as only this thread will
+    // ever modify the returned value.
+    valueMap.put(Thread.currentThread(), value == null ? NULL : value);
+  }
 }