Locale.java (hashcode): Made transient.

	* java/util/Locale.java (hashcode): Made transient.
	(hashCode): No longer synchronized.
	(equals): Remove comment.
	(writeObject): No longer synchronized. Implement using writeObject
	calls instead of tweaking hashCode field. Update doc.
	(readObject): Implement using readObject calls.

From-SVN: r84027

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 8df39520d91a019fc6f048da4506b56488f4ee57..d99f402ccc0d2513fdec12fbc1e20e417ebd8edc 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,12 @@
+2004-07-02  Bryce McKinlay  <mckinlay@redhat.com>
+
+       * java/util/Locale.java (hashcode): Made transient.
+       (hashCode): No longer synchronized.
+       (equals): Remove comment.
+       (writeObject): No longer synchronized. Implement using writeObject 
+       calls instead of tweaking hashCode field. Update doc.
+       (readObject): Implement using readObject calls.
+
 2004-06-26  Geoffrey Keating  <geoffk@apple.com>
            Andreas Tobler  <a.tobler@schweiz.ch>
 

diff --git a/libjava/java/util/Locale.java b/libjava/java/util/Locale.java
index cc6d65f5f6564964e07f2f044b4df5e573cba54a..ca6334cb33497ffc46584544936a64e9e082bb34 100644 (file)
--- a/libjava/java/util/Locale.java
+++ b/libjava/java/util/Locale.java
@@ -186,7 +186,7 @@ public final class Locale implements Serializable, Cloneable
    *
    * @serial should be -1 in serial streams
    */
-  private int hashcode;
+  private transient int hashcode;
 
   /**
    * The default locale. Except for during bootstrapping, this should never be
@@ -709,10 +709,8 @@ public final class Locale implements Serializable, Cloneable
    *
    * @return the hashcode
    */
-  public synchronized int hashCode()
+  public int hashCode()
   {
-    // This method is synchronized because writeObject() might reset
-    // the hashcode.
     return hashcode;
   }
 
@@ -731,10 +729,6 @@ public final class Locale implements Serializable, Cloneable
       return false;
     Locale l = (Locale) obj;
 
-    // ??? We might also want to add:
-    //        hashCode() == l.hashCode()
-    // But this is a synchronized method.  Is the overhead worth it?
-    // Measure this to make a decision.
     return (language == l.language
             && country == l.country
             && variant == l.variant);
@@ -745,17 +739,19 @@ public final class Locale implements Serializable, Cloneable
    *
    * @param output the stream to write to
    * @throws IOException if the write fails
-   * @serialData the hashcode should always be written as -1, and recomputed
-   *      when reading it back
+   * @serialData The first three fields are Strings representing language,
+   *             country, and variant. The fourth field is a placeholder for 
+   *             the cached hashcode, but this is always written as -1, and 
+   *             recomputed when reading it back.
    */
-  private synchronized void writeObject(ObjectOutputStream output)
+  private void writeObject(ObjectOutputStream s)
     throws IOException
   {
-    // Synchronized so that hashCode() doesn't get wrong value.
-    int tmpHashcode = hashcode;
-    hashcode = -1;
-    output.defaultWriteObject();
-    hashcode = tmpHashcode;
+    s.writeObject(language);
+    s.writeObject(country);
+    s.writeObject(variant);
+    // Hashcode field is always written as -1.
+    s.writeInt(-1);
   }
 
   /**
@@ -766,10 +762,13 @@ public final class Locale implements Serializable, Cloneable
    * @throws ClassNotFoundException if reading fails
    * @serialData the hashCode is always invalid and must be recomputed
    */
-  private void readObject(ObjectInputStream input)
+  private void readObject(ObjectInputStream s)
     throws IOException, ClassNotFoundException
   {
-    input.defaultReadObject();
+    language = (String) s.readObject();
+    country = (String) s.readObject();
+    variant = (String) s.readObject();    
+    // Recompute hashcode.
     hashcode = language.hashCode() ^ country.hashCode() ^ variant.hashCode();
   }
 } // class Locale