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