[PATCH 1/2] Class local storage (original) (raw)

Thu Feb 26 16:05:30 UTC 2009

   final Map<Object, Object> classLocalData = this.classLocalData;
   if (classLocalData != null) {
       return classLocalData;
   } else {
       return (this.classLocalData = new WeakHashMap<Object, Object>());
   }
* Construct a new instance.  A new instance will contain no mappings.
*/
* Determine whether the given class has a mapping for this variable (even
* if it is {@code null}).
*
* @param clazz the class to check
*
* @return {@code true} if the given class contains a value for this
*         class-local
*/
   synchronized (clazz) {
       return clazz.getClassLocalMap().containsKey(key);
   }
* Get the value associated with the given class for this variable.
*
* @return the value associated with the given class, or {@code null} if
*         there is no mapping (a {@code null} return could also indicate
*         that a {@code null} value is stored in this variable)
*/
   synchronized (clazz) {
       return (T) clazz.getClassLocalMap().get(key);
   }
* Associate a new value with the given class for this variable.
*
* @param clazz the class to update
* @param value the value to associate
*
* @return the previous value associated with this variable, or {@code
*         if there was no mapping (a {@code null} return could also
*         indicate that a {@code null} value was stored in this variable)
*/
   synchronized (clazz) {
       return (T) clazz.getClassLocalMap().put(key, value);
   }
* Associate a value with the given class for this variable if there was
* previously no mapping.
*
* @param clazz the class to update
* @param value the value to associate
*
* @return the previous value associated with this variable, or {@code
*         if there was no mapping (a {@code null} return could also
*         indicate that a {@code null} value was stored in this variable)
*/
   synchronized (clazz) {
       final Object key = this.key;
       final Map<Object, Object> cldMap = clazz.getClassLocalMap();
       if (cldMap.containsKey(key)) {
           return (T) cldMap.get(key);
       } else {
           cldMap.put(key, value);
           return null;
       }
   }
* Get and remove the value of this variable.  After this method returns,
* there will be no value stored in this variable for the given class
* (calling {@code hasValue(clazz)} for this class and variable will
* {@code false}).
*
* @param clazz the class to update
*
* @return the previous value associated with this variable, or {@code
*         if there was no mapping (a {@code null} return could also
*         indicate that a {@code null} value was stored in this variable)
*/
   synchronized (clazz) {
       return (T) clazz.getClassLocalMap().remove(key);
   }
* Remove the entry for this variable only if it is currently set to a
* value.
*
* @param clazz the class to update
* @param oldValue the value expected to be associated with the variable
*
* @return {@code true} if the value was removed
*/
   synchronized (clazz) {
       final Map<Object, Object> clMap = clazz.getClassLocalMap();
       final Object key = this.key;
       if (clMap.containsKey(key) && clMap.get(key).equals(oldValue)) {
           clMap.remove(key);
           return true;
       } else {
           return false;
       }
   }
* Replace the entry for this variable, returning the old value.
*
* @param clazz the class to update
* @param newValue the value to associate with this variable
*
* @return the previous value associated with this variable, or {@code
*         if there was no mapping (a {@code null} return could also
*         indicate that a {@code null} value was stored in this variable)
*/
   synchronized (clazz) {
       final Map<Object, Object> clMap = clazz.getClassLocalMap();
       if (clMap.containsKey(key)) {
           return (T) clMap.put(key, newValue);
       } else {
           return null;
       }
   }
* Replace the entry for this variable, if it was previously set to a
* value.
*
* @param clazz the class to update
* @param oldValue the value expected to be associated with the variable
* @param newValue the value to associate with this variable
*
* @return {@code true} if the value was replaced
*/
   synchronized (clazz) {
       final Map<Object, Object> clMap = clazz.getClassLocalMap();
       final Object key = this.key;
       if (clMap.containsKey(key) && clMap.get(key).equals(oldValue)) {
           clMap.put(key, newValue);
           return true;
       } else {
           return false;
       }
   }
* Cause all existing mappings to be cleared.  Once this method is called,
* prior values are no longer retrievable.
*/
   key = new Object();