gov/nasa/worldwind/avlist/AVListImpl.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.avlist;
   8
   9 import gov.nasa.worldwind.exception.WWRuntimeException;
  10 import gov.nasa.worldwind.util.Logging;
  11
  12 import java.util.*;
  13 import java.util.logging.Level;
  14
  15 /**
  16  * An implementation class for the {@link AVList} interface. Classes implementing <code>AVList</code> can subclass or
  17  * aggreate this class to provide default <code>AVList</code> functionality. This class maintains a hash table of
  18  * attribute-value pairs.
  19  * <p/>
  20  * This class implements a notification mechanism for attribute-value changes. The mechanism provides a means for
  21  * objects to observe attribute changes or queries for certain keys without explicitly monitoring all keys. See {@link
  22  * java.beans.PropertyChangeSupport}.
  23  *
  24  * @author Tom Gaskins
  25  * @version $Id: AVListImpl.java 2471 2007-07-31 21:50:57Z tgaskins $
  26  */
  27 public class AVListImpl implements AVList, java.beans.PropertyChangeListener
  28 {
  29     // TODO: Make thread-safe
  30     /**
  31      * Available to sub-classes for further exposure of property-change functionality.
  32      */
  33     protected final java.beans.PropertyChangeSupport changeSupport;// = new java.beans.PropertyChangeSupport(this);
  34
  35     // To avoid unnecessary overhead, this object's hash map is created only if needed.
  36     private Map<String, Object> avList;
  37
  38     /**
  39      * Creates an empty attribute-value list.
  40      */
  41     public AVListImpl()
  42     {
  43         this.changeSupport = new java.beans.PropertyChangeSupport(this);
  44     }
  45
  46     /**
  47      * Constructor enabling aggregation
  48      * @param sourceBean The bean to be given as the soruce for any events.
  49      */
  50     public AVListImpl(Object sourceBean)
  51     {
  52         // TODO: check arg for non-null
  53         this.changeSupport = new java.beans.PropertyChangeSupport(sourceBean);
  54     }
  55
  56     private boolean hasAvList()
  57     {
  58         return this.avList != null;
  59     }
  60
  61     private Map<String, Object> createAvList()
  62     {
  63         if (!this.hasAvList())
  64         {
  65             this.avList = new java.util.HashMap<String, Object>();
  66         }
  67
  68         return this.avList;
  69     }
  70
  71     private Map<String, Object> avList(boolean createIfNone)
  72     {
  73         if (createIfNone && !this.hasAvList())
  74             this.createAvList();
  75
  76         return this.avList;
  77     }
  78
  79     public final Object getValue(String key)
  80     {
  81         if (key == null)
  82         {
  83             String message = Logging.getMessage("nullValue.AttributeKeyIsNull");
  84             Logging.logger().severe(message);
  85             throw new IllegalArgumentException(message);
  86         }
  87
  88         if (this.hasAvList())
  89             return this.avList.get(key);
  90
  91         return null;
  92     }
  93
  94     public final Collection<Object> getValues()
  95     {
  96         return this.hasAvList() ? this.avList.values() : this.createAvList().values();
  97     }
  98
  99     public Set<Map.Entry<String, Object>> getEntries()
 100     {
 101         return this.hasAvList() ? this.avList.entrySet() : this.createAvList().entrySet();
 102     }
 103
 104     public final String getStringValue(String key)
 105     {
 106         if (key == null)
 107         {
 108             String msg = Logging.getMessage("nullValue.AttributeKeyIsNull");
 109             Logging.logger().severe(msg);
 110             throw new IllegalStateException(msg);
 111         }
 112         try
 113         {
 114             return (String) this.getValue(key);
 115         }
 116         catch (ClassCastException e)
 117         {
 118             String msg = Logging.getMessage("AVAAccessibleImpl.AttributeValueForKeyIsNotAString", key);
 119             Logging.logger().severe(msg);
 120             throw new WWRuntimeException(msg, e);
 121         }
 122     }
 123
 124     public final void setValue(String key, Object value)
 125     {
 126         if (key == null)
 127         {
 128             String message = Logging.getMessage("nullValue.AttributeKeyIsNull");
 129             Logging.logger().severe(message);
 130             throw new IllegalArgumentException(message);
 131         }
 132         // Capture the existing value if there is one, then set the new value.
 133         this.avList(true).put(key, value);
 134     }
 135
 136     public final void setValues(AVList list)
 137     {
 138         if (list == null)
 139         {
 140             String message = Logging.getMessage("nullValue.AttributesIsNull");
 141             Logging.logger().severe(message);
 142             throw new IllegalArgumentException(message);
 143         }
 144
 145         Set<Map.Entry<String, Object>> entries = list.getEntries();
 146         for (Map.Entry<String, Object> entry : entries)
 147             this.setValue(entry.getKey(), entry.getValue());
 148     }
 149
 150     public final boolean hasKey(String key)
 151     {
 152         if (key == null)
 153         {
 154             String message = Logging.getMessage("nullValue.KeyIsNull");
 155             Logging.logger().severe(message);
 156             throw new IllegalArgumentException(message);
 157         }
 158
 159         return this.hasAvList() && this.avList.containsKey(key);
 160     }
 161
 162     public final void removeKey(String key)
 163     {
 164         if (key == null)
 165         {
 166             String message = Logging.getMessage("nullValue.KeyIsNull");
 167             Logging.logger().severe(message);
 168             throw new IllegalArgumentException(message);
 169         }
 170
 171         if (this.hasKey(key))
 172             this.avList.remove(key);
 173     }
 174
 175     public AVList copy()
 176     {
 177         AVListImpl clone = new AVListImpl();
 178
 179         clone.createAvList();
 180         clone.avList.putAll(this.avList);
 181
 182         return clone;
 183     }
 184
 185     public final AVList clearList()
 186     {
 187         if (this.hasAvList())
 188             this.avList.clear();
 189         return this;
 190     }
 191
 192     public void addPropertyChangeListener(String propertyName, java.beans.PropertyChangeListener listener)
 193     {
 194         if (propertyName == null)
 195         {
 196             String msg = Logging.getMessage("nullValue.PropertyNameIsNull");
 197             Logging.logger().severe(msg);
 198             throw new IllegalArgumentException(msg);
 199         }
 200         if (listener == null)
 201         {
 202             String msg = Logging.getMessage("nullValue.ListenerIsNull");
 203             Logging.logger().severe(msg);
 204             throw new IllegalArgumentException(msg);
 205         }
 206         this.changeSupport.addPropertyChangeListener(propertyName, listener);
 207     }
 208
 209     public void removePropertyChangeListener(String propertyName, java.beans.PropertyChangeListener listener)
 210     {
 211         if (propertyName == null)
 212         {
 213             String msg = Logging.getMessage("nullValue.PropertyNameIsNull");
 214             Logging.logger().severe(msg);
 215             throw new IllegalArgumentException(msg);
 216         }
 217         if (listener == null)
 218         {
 219             String msg = Logging.getMessage("nullValue.ListenerIsNull");
 220             Logging.logger().severe(msg);
 221             throw new IllegalArgumentException(msg);
 222         }
 223         this.changeSupport.removePropertyChangeListener(propertyName, listener);
 224     }
 225
 226     public void addPropertyChangeListener(java.beans.PropertyChangeListener listener)
 227     {
 228         if (listener == null)
 229         {
 230             String msg = Logging.getMessage("nullValue.ListenerIsNull");
 231             Logging.logger().severe(msg);
 232             throw new IllegalArgumentException(msg);
 233         }
 234         this.changeSupport.addPropertyChangeListener(listener);
 235     }
 236
 237     public void removePropertyChangeListener(java.beans.PropertyChangeListener listener)
 238     {
 239         if (listener == null)
 240         {
 241             String msg = Logging.getMessage("nullValue.ListenerIsNull");
 242             Logging.logger().severe(msg);
 243             throw new IllegalArgumentException(msg);
 244         }
 245         this.changeSupport.removePropertyChangeListener(listener);
 246     }
 247
 248     public void firePropertyChange(java.beans.PropertyChangeEvent propertyChangeEvent)
 249     {
 250         if (propertyChangeEvent == null)
 251         {
 252             String msg = Logging.getMessage("nullValue.PropertyChangeEventIsNull");
 253             Logging.logger().severe(msg);
 254             throw new IllegalArgumentException(msg);
 255         }
 256         this.changeSupport.firePropertyChange(propertyChangeEvent);
 257     }
 258
 259     public void firePropertyChange(String propertyName, Object oldValue, Object newValue)
 260     {
 261         if (propertyName == null)
 262         {
 263             String msg = Logging.getMessage("nullValue.PropertyNameIsNull");
 264             Logging.logger().severe(msg);
 265             throw new IllegalArgumentException(msg);
 266         }
 267         this.changeSupport.firePropertyChange(propertyName, oldValue, newValue);
 268     }
 269
 270     /**
 271      * The property change listener for <em>this</em> instance.
 272      * Recieves property change notifications that this instance has registered with other proprty change notifiers.
 273      * @param propertyChangeEvent the event
 274      * @throws IllegalArgumentException if <code>propertyChangeEvent</code> is null
 275      */
 276     public void propertyChange(java.beans.PropertyChangeEvent propertyChangeEvent)
 277     {
 278         if (propertyChangeEvent == null)
 279         {
 280             String msg = Logging.getMessage("nullValue.PropertyChangeEventIsNull");
 281             Logging.logger().severe(msg);
 282             throw new IllegalArgumentException(msg);
 283         }
 284
 285         // Notify all *my* listeners of the change that I caught
 286         this.changeSupport.firePropertyChange(propertyChangeEvent);
 287     }
 288
 289
 290     // Static AVList utilities.
 291     public static String getStringValue(AVList avList, String key, String defaultValue)
 292     {
 293         String v = getStringValue(avList, key);
 294         return v != null ? v : defaultValue;
 295     }
 296
 297     public static String getStringValue(AVList avList, String key)
 298     {
 299         try
 300         {
 301             return avList.getStringValue(key);
 302         }
 303         catch (Exception e)
 304         {
 305             return null;
 306         }
 307     }
 308
 309     public static Integer getIntegerValue(AVList avList, String key, Integer defaultValue)
 310     {
 311         Integer v = getIntegerValue(avList, key);
 312         return v != null ? v : defaultValue;
 313     }
 314
 315     public static Integer getIntegerValue(AVList avList, String key)
 316     {
 317         Object o = avList.getValue(key);
 318         if (o == null)
 319             return null;
 320
 321         if (o instanceof Integer)
 322             return (Integer) o;
 323
 324         String v = getStringValue(avList, key);
 325         if (v == null)
 326             return null;
 327
 328         try
 329         {
 330             return Integer.parseInt(v);
 331         }
 332         catch (NumberFormatException e)
 333         {
 334             Logging.logger().log(Level.SEVERE, "Configuration.ConversionError", v);
 335             return null;
 336         }
 337     }
 338
 339     public static Long getLongValue(AVList avList, String key, Long defaultValue)
 340     {
 341         Long v = getLongValue(avList, key);
 342         return v != null ? v : defaultValue;
 343     }
 344
 345     public static Long getLongValue(AVList avList, String key)
 346     {
 347         Object o = avList.getValue(key);
 348         if (o == null)
 349             return null;
 350
 351         if (o instanceof Long)
 352             return (Long) o;
 353
 354         String v = getStringValue(avList, key);
 355         if (v == null)
 356             return null;
 357
 358         try
 359         {
 360             return Long.parseLong(v);
 361         }
 362         catch (NumberFormatException e)
 363         {
 364             Logging.logger().log(Level.SEVERE, "Configuration.ConversionError", v);
 365             return null;
 366         }
 367     }
 368
 369     public static Double getDoubleValue(AVList avList, String key, Double defaultValue)
 370     {
 371         Double v = getDoubleValue(avList, key);
 372         return v != null ? v : defaultValue;
 373     }
 374
 375     public static Double getDoubleValue(AVList avList, String key)
 376     {
 377         Object o = avList.getValue(key);
 378         if (o == null)
 379             return null;
 380
 381         if (o instanceof Double)
 382             return (Double) o;
 383
 384         String v = getStringValue(avList, key);
 385         if (v == null)
 386             return null;
 387
 388         try
 389         {
 390             return Double.parseDouble(v);
 391         }
 392         catch (NumberFormatException e)
 393         {
 394             Logging.logger().log(Level.SEVERE, "Configuration.ConversionError", v);
 395             return null;
 396         }
 397     }
 398 }