Changeset 10824 in josm for trunk/src/org/openstreetmap/josm/data

Timestamp:

2016-08-17T09:18:31+02:00 (8 years ago)

Author:

Don-vip

Message:

see #13309 - Caching and notifying preferences (patch by michael2402) - gsoc-core

Location:

trunk/src/org/openstreetmap/josm/data

Files:

• Preferences.java (modified) (13 diffs)
• osm/visitor/paint/PaintColors.java (modified) (4 diffs)
• preferences/AbstractProperty.java (modified) (7 diffs)
• preferences/AbstractToStringProperty.java (added)
• preferences/BooleanProperty.java (modified) (2 diffs)
• preferences/CachedProperty.java (modified) (2 diffs)
• preferences/CachingProperty.java (added)
• preferences/CollectionProperty.java (modified) (1 diff)
• preferences/ColorProperty.java (modified) (4 diffs)
• preferences/DoubleProperty.java (modified) (3 diffs)
• preferences/IntegerProperty.java (modified) (2 diffs)
• preferences/LongProperty.java (modified) (3 diffs)
• preferences/PreferencesWriter.java (modified) (3 diffs)
• preferences/StringProperty.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/data/Preferences.java

@@ -37 +37 @@
 import java.util.SortedMap;
 import java.util.TreeMap;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.function.Predicate;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Stream;
 
 import javax.json.Json;
@@ -55 +55 @@
 
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.preferences.BooleanProperty;
 import org.openstreetmap.josm.data.preferences.ColorProperty;
+import org.openstreetmap.josm.data.preferences.DoubleProperty;
+import org.openstreetmap.josm.data.preferences.IntegerProperty;
 import org.openstreetmap.josm.data.preferences.ListListSetting;
 import org.openstreetmap.josm.data.preferences.ListSetting;
+import org.openstreetmap.josm.data.preferences.LongProperty;
 import org.openstreetmap.josm.data.preferences.MapListSetting;
 import org.openstreetmap.josm.data.preferences.PreferencesReader;
@@ -68 +72 @@
 import org.openstreetmap.josm.tools.ColorHelper;
 import org.openstreetmap.josm.tools.I18n;
+import org.openstreetmap.josm.tools.ListenerList;
 import org.openstreetmap.josm.tools.MultiMap;
-import org.openstreetmap.josm.tools.SubclassFilteredCollection;
 import org.openstreetmap.josm.tools.Utils;
 import org.xml.sax.SAXException;
@@ -215 +219 @@
     }
 
+    /**
+     * Old color interface
+     * <p>
+     * To be removed: end of 2016
+     * @deprecated Use a {@link ColorProperty} instead.
+     */
+    @Deprecated
     public interface ColorKey {
         String getColorName();
@@ -223 +234 @@
     }
 
-    private final CopyOnWriteArrayList<PreferenceChangedListener> listeners = new CopyOnWriteArrayList<>();
+    private final ListenerList<PreferenceChangedListener> listeners = ListenerList.create();
+
+    private final HashMap<String, ListenerList<PreferenceChangedListener>> keyListeners = new HashMap<>();
 
     /**
@@ -231 +244 @@
     public void addPreferenceChangeListener(PreferenceChangedListener listener) {
         if (listener != null) {
-            listeners.addIfAbsent(listener);
+            listeners.addListener(listener);
         }
     }
@@ -240 +253 @@
      */
     public void removePreferenceChangeListener(PreferenceChangedListener listener) {
-        listeners.remove(listener);
+        listeners.removeListener(listener);
+    }
+
+    /**
+     * Adds a listener that only listens to changes in one preference
+     * @param key The preference key to listen to
+     * @param listener The listener to add.
+     * @since 10824
+     */
+    public void addKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
+        listenersForKey(key).addListener(listener);
+    }
+
+    /**
+     * Adds a weak listener that only listens to changes in one preference
+     * @param key The preference key to listen to
+     * @param listener The listener to add.
+     * @since 10824
+     */
+    public void addWeakKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
+        listenersForKey(key).addWeakListener(listener);
+    }
+
+    private ListenerList<PreferenceChangedListener> listenersForKey(String key) {
+        ListenerList<PreferenceChangedListener> keyListener = keyListeners.get(key);
+        if (keyListener == null) {
+            keyListener = ListenerList.create();
+            keyListeners.put(key, keyListener);
+        }
+        return keyListener;
+    }
+
+    /**
+     * Removes a listener that only listens to changes in one preference
+     * @param key The preference key to listen to
+     * @param listener The listener to add.
+     */
+    public void removeKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
+        ListenerList<PreferenceChangedListener> keyListener = keyListeners.get(key);
+        if (keyListener == null) {
+            throw new IllegalArgumentException("There are no listeners registered for " + key);
+        }
+        keyListener.removeListener(listener);
     }
 
     protected void firePreferenceChanged(String key, Setting<?> oldValue, Setting<?> newValue) {
-        PreferenceChangeEvent evt = new DefaultPreferenceChangeEvent(key, oldValue, newValue);
-        for (PreferenceChangedListener l : listeners) {
-            l.preferenceChanged(evt);
+        final PreferenceChangeEvent evt = new DefaultPreferenceChangeEvent(key, oldValue, newValue);
+        listeners.fireEvent(listener -> listener.preferenceChanged(evt));
+
+        ListenerList<PreferenceChangedListener> forKey = keyListeners.get(key);
+        if (forKey != null) {
+            forKey.fireEvent(listener -> listener.preferenceChanged(evt));
         }
     }
@@ -479 +537 @@
      */
     public boolean put(final String key, String value) {
-        if (value != null && value.isEmpty()) {
-            value = null;
-        }
-        return putSetting(key, value == null ? null : new StringSetting(value));
-    }
-
+        return putSetting(key, value == null || value.isEmpty() ? null : new StringSetting(value));
+    }
+
+    /**
+     * Set a boolean value for a certain setting.
+     * @param key the unique identifier for the setting
+     * @param value The new value
+     * @return {@code true}, if something has changed (i.e. value is different than before)
+     * @see BooleanProperty
+     */
     public boolean put(final String key, final boolean value) {
         return put(key, Boolean.toString(value));
     }
 
+    /**
+     * Set a boolean value for a certain setting.
+     * @param key the unique identifier for the setting
+     * @param value The new value
+     * @return {@code true}, if something has changed (i.e. value is different than before)
+     * @see IntegerProperty
+     */
     public boolean putInteger(final String key, final Integer value) {
         return put(key, Integer.toString(value));
     }
 
+    /**
+     * Set a boolean value for a certain setting.
+     * @param key the unique identifier for the setting
+     * @param value The new value
+     * @return {@code true}, if something has changed (i.e. value is different than before)
+     * @see DoubleProperty
+     */
     public boolean putDouble(final String key, final Double value) {
         return put(key, Double.toString(value));
     }
 
+    /**
+     * Set a boolean value for a certain setting.
+     * @param key the unique identifier for the setting
+     * @param value The new value
+     * @return {@code true}, if something has changed (i.e. value is different than before)
+     * @see LongProperty
+     */
     public boolean putLong(final String key, final Long value) {
         return put(key, Long.toString(value));
@@ -506 +589 @@
      */
     public synchronized void save() throws IOException {
-        save(getPreferenceFile(),
-                new SubclassFilteredCollection<>(settingsMap.entrySet(), NO_DEFAULT_SETTINGS_ENTRY), false);
+        save(getPreferenceFile(), settingsMap.entrySet().stream().filter(NO_DEFAULT_SETTINGS_ENTRY), false);
     }
 
     public synchronized void saveDefaults() throws IOException {
-        save(getDefaultsCacheFile(), defaultsMap.entrySet(), true);
-    }
-
-    protected void save(File prefFile, Collection<Entry<String, Setting<?>>> settings, boolean defaults) throws IOException {
-
+        save(getDefaultsCacheFile(), defaultsMap.entrySet().stream(), true);
+    }
+
+    protected void save(File prefFile, Stream<Entry<String, Setting<?>>> settings, boolean defaults) throws IOException {
         if (!defaults) {
             /* currently unused, but may help to fix configuration issues in future */
@@ -719 +800 @@
     /**
      * Convenience method for accessing colour preferences.
+     * <p>
+     * To be removed: end of 2016
      *
      * @param colName name of the colour
      * @param def default value
      * @return a Color object for the configured colour, or the default value if none configured.
-     */
+     * @deprecated Use a {@link ColorProperty} instead.
+     */
+    @Deprecated
     public synchronized Color getColor(String colName, Color def) {
         return getColor(colName, null, def);
@@ -743 +828 @@
     /**
      * Returns the color for the given key.
+     * <p>
+     * To be removed: end of 2016
      * @param key The color key
      * @return the color
-     */
+     * @deprecated Use a {@link ColorProperty} instead.
+     */
+    @Deprecated
     public Color getColor(ColorKey key) {
         return getColor(key.getColorName(), key.getSpecialName(), key.getDefaultValue());
@@ -752 +841 @@
     /**
      * Convenience method for accessing colour preferences.
-     *
+     * <p>
+     * To be removed: end of 2016
      * @param colName name of the colour
      * @param specName name of the special colour settings
      * @param def default value
      * @return a Color object for the configured colour, or the default value if none configured.
-     */
+     * @deprecated Use a {@link ColorProperty} instead.
+     * You can replace this by: <code>new ColorProperty(colName, def).getChildColor(specName)</code>
+     */
+    @Deprecated
     public synchronized Color getColor(String colName, String specName, Color def) {
         String colKey = ColorProperty.getColorKey(colName);
-        if (!colKey.equals(colName)) {
-            colornames.put(colKey, colName);
-        }
+        registerColor(colKey, colName);
         String colStr = specName != null ? get("color."+specName) : "";
         if (colStr.isEmpty()) {
@@ -771 +862 @@
         } else {
             return def;
+        }
+    }
+
+    /**
+     * Registers a color name conversion for the global color registry.
+     * @param colKey The key
+     * @param colName The name of the color.
+     * @since 10824
+     */
+    public void registerColor(String colKey, String colName) {
+        if (!colKey.equals(colName)) {
+            colornames.put(colKey, colName);
         }
     }

trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/PaintColors.java

@@ -7 +7 @@
 import java.util.List;
 
-import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.data.Preferences.ColorKey;
+import org.openstreetmap.josm.data.preferences.CachingProperty;
+import org.openstreetmap.josm.data.preferences.ColorProperty;
 import org.openstreetmap.josm.gui.mappaint.MapPaintStyles;
 import org.openstreetmap.josm.gui.mappaint.MapPaintStyles.MapPaintSylesUpdateListener;
 import org.openstreetmap.josm.gui.mappaint.StyleSource;
 
-public enum PaintColors implements ColorKey {
+public enum PaintColors {
 
     INACTIVE(marktr("inactive"), Color.darkGray),
@@ -34 +34 @@
     private final String name;
     private final Color defaultColor;
+    private final CachingProperty<Color> property;
 
     private static volatile Color backgroundColorCache;
 
     private static final MapPaintSylesUpdateListener styleOverrideListener = new MapPaintSylesUpdateListener() {
-
+        //TODO: Listen to wireframe map mode changes.
         @Override
         public void mapPaintStylesUpdated() {
@@ -55 +56 @@
 
     PaintColors(String name, Color defaultColor) {
+        property = new ColorProperty(name, defaultColor).cached();
         this.name = name;
         this.defaultColor = defaultColor;
     }
 
-    @Override
-    public String getColorName() {
-        return name;
-    }
-
-    @Override
     public Color getDefaultValue() {
-        return defaultColor;
-    }
-
-    @Override
-    public String getSpecialName() {
-        return null;
+        return property.getDefaultValue();
     }
 
     public Color get() {
-        return Main.pref.getColor(this);
-    }
-
-    public static void getColors() {
-        for (PaintColors c:values()) {
-            c.get();
-        }
+        return property.get();
     }
 
@@ -98 +83 @@
         }
         if (backgroundColorCache == null) {
-            backgroundColorCache = BACKGROUND.get();
+            return BACKGROUND.get();
+        } else {
+            return backgroundColorCache;
         }
-        return backgroundColorCache;
     }
 }

trunk/src/org/openstreetmap/josm/data/preferences/AbstractProperty.java

@@ -3 +3 @@
 
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.Preferences;
+import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
+import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
 
 /**
@@ -9 +12 @@
  */
 public abstract class AbstractProperty<T> {
+
+    private final class PreferenceChangedListenerAdapter implements PreferenceChangedListener {
+        private ValueChangeListener<? super T> listener;
+
+        PreferenceChangedListenerAdapter(ValueChangeListener<? super T> listener) {
+            this.listener = listener;
+        }
+
+        @Override
+        public void preferenceChanged(PreferenceChangeEvent e) {
+            listener.valueChanged(new ValueChangeEvent<>(e, AbstractProperty.this));
+        }
+
+        @Override
+        public int hashCode() {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result + getOuterType().hashCode();
+            result = prime * result + ((listener == null) ? 0 : listener.hashCode());
+            return result;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (getClass() != obj.getClass())
+                return false;
+            @SuppressWarnings("unchecked")
+            PreferenceChangedListenerAdapter other = (PreferenceChangedListenerAdapter) obj;
+            if (!getOuterType().equals(other.getOuterType()))
+                return false;
+            if (listener == null) {
+                if (other.listener != null)
+                    return false;
+            } else if (!listener.equals(other.listener))
+                return false;
+            return true;
+        }
+
+        private AbstractProperty<T> getOuterType() {
+            return AbstractProperty.this;
+        }
+
+        @Override
+        public String toString() {
+            return "PreferenceChangedListenerAdapter [listener=" + listener + ']';
+        }
+    }
+
+    /**
+     * A listener that listens to changes in the properties value.
+     * @author michael
+     * @param <T> property type
+     * @since 10824
+     */
+    public interface ValueChangeListener<T> {
+        /**
+         * Method called when a property value has changed.
+         * @param e property change event
+         */
+        void valueChanged(ValueChangeEvent<? extends T> e);
+    }
+
+    /**
+     * An event that is triggered if the value of a property changes.
+     * @author Michael Zangl
+     * @param <T> property type
+     * @since 10824
+     */
+    public static class ValueChangeEvent<T> {
+        private final PreferenceChangeEvent base;
+
+        private final AbstractProperty<T> source;
+
+        ValueChangeEvent(PreferenceChangeEvent base, AbstractProperty<T> source) {
+            this.base = base;
+            this.source = source;
+        }
+
+        /**
+         * Get the property that was changed
+         * @return The property.
+         */
+        public AbstractProperty<T> getProperty() {
+            return source;
+        }
+    }
+
+    /**
+     * An exception that is thrown if a preference value is invalid.
+     * @author Michael Zangl
+     * @since 10824
+     */
+    public static class InvalidPreferenceValueException extends RuntimeException {
+
+        /**
+         * Constructs a new {@code InvalidPreferenceValueException} with the specified detail message and cause.
+         * @param message the detail message (which is saved for later retrieval by the {@link #getMessage()} method).
+         * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method).
+         */
+        public InvalidPreferenceValueException(String message, Throwable cause) {
+            super(message, cause);
+        }
+
+        /**
+         * Constructs a new {@code InvalidPreferenceValueException} with the specified detail message.
+         * The cause is not initialized, and may subsequently be initialized by a call to {@link #initCause}.
+         *
+         * @param message the detail message. The detail message is saved for later retrieval by the {@link #getMessage()} method.
+         */
+        public InvalidPreferenceValueException(String message) {
+            super(message);
+        }
+
+        /**
+         * Constructs a new {@code InvalidPreferenceValueException} with the specified cause and a detail message of
+         * <tt>(cause==null ? null : cause.toString())</tt> (which typically contains the class and detail message of <tt>cause</tt>).
+         *
+         * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method).
+         */
+        public InvalidPreferenceValueException(Throwable cause) {
+            super(cause);
+        }
+    }
+
+    /**
+     * The preferences object this property is for.
+     */
+    protected final Preferences preferences;
     protected final String key;
     protected final T defaultValue;
@@ -19 +154 @@
      */
     public AbstractProperty(String key, T defaultValue) {
+        // Main.pref should not change in production but may change during tests.
+        preferences = Main.pref;
         this.key = key;
         this.defaultValue = defaultValue;
@@ -24 +161 @@
 
     /**
+     * Store the default value to {@link Preferences}.
+     */
+    protected void storeDefaultValue() {
+        if (getPreferences() != null) {
+            get();
+        }
+    }
+
+    /**
      * Replies the property key.
      * @return The property key
@@ -36 +182 @@
      */
     public boolean isSet() {
-        return !Main.pref.get(key).isEmpty();
+        return !getPreferences().get(key).isEmpty();
     }
 
@@ -51 +197 @@
      */
     public void remove() {
-        Main.pref.put(getKey(), String.valueOf(getDefaultValue()));
+        put(getDefaultValue());
     }
 
@@ -68 +214 @@
      */
     public abstract boolean put(T value);
+
+    /**
+     * Gets the preferences used for this property.
+     * @return The preferences for this property.
+     * @since 10824
+     */
+    protected Preferences getPreferences() {
+        return preferences;
+    }
+
+    /**
+     * Adds a listener that listens only for changes to this preference key.
+     * @param listener The listener to add.
+     * @since 10824
+     */
+    public void addListener(ValueChangeListener<? super T> listener) {
+        addListenerImpl(new PreferenceChangedListenerAdapter(listener));
+    }
+
+    protected void addListenerImpl(PreferenceChangedListener adapter) {
+        getPreferences().addKeyPreferenceChangeListener(getKey(), adapter);
+    }
+
+    /**
+     * Adds a weak listener that listens only for changes to this preference key.
+     * @param listener The listener to add.
+     * @since 10824
+     */
+    public void addWeakListener(ValueChangeListener<? super T> listener) {
+        addWeakListenerImpl(new PreferenceChangedListenerAdapter(listener));
+    }
+
+    protected void addWeakListenerImpl(PreferenceChangedListener adapter) {
+        getPreferences().addWeakKeyPreferenceChangeListener(getKey(), adapter);
+    }
+
+    /**
+     * Removes a listener that listens only for changes to this preference key.
+     * @param listener The listener to add.
+     * @since 10824
+     */
+    public void removeListener(ValueChangeListener<? super T> listener) {
+        removeListenerImpl(new PreferenceChangedListenerAdapter(listener));
+    }
+
+    protected void removeListenerImpl(PreferenceChangedListener adapter) {
+        getPreferences().removeKeyPreferenceChangeListener(getKey(), adapter);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((key == null) ? 0 : key.hashCode());
+        result = prime * result + ((preferences == null) ? 0 : preferences.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        AbstractProperty<?> other = (AbstractProperty<?>) obj;
+        if (key == null) {
+            if (other.key != null)
+                return false;
+        } else if (!key.equals(other.key))
+            return false;
+        if (preferences == null) {
+            if (other.preferences != null)
+                return false;
+        } else if (!preferences.equals(other.preferences))
+            return false;
+        return true;
+    }
 }

trunk/src/org/openstreetmap/josm/data/preferences/BooleanProperty.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.preferences;
-
-import org.openstreetmap.josm.Main;
 
 /**
  * A property containing a {@code Boolean} value.
  */
-public class BooleanProperty extends AbstractProperty<Boolean> {
+public class BooleanProperty extends AbstractToStringProperty<Boolean> {
 
     /**
@@ -16 +14 @@
     public BooleanProperty(String key, boolean defaultValue) {
         super(key, defaultValue);
-        if (Main.pref != null) {
-            get();
-        }
     }
 
     @Override
     public Boolean get() {
-        return Main.pref.getBoolean(getKey(), defaultValue);
+        // Removing this implementation breaks binary compatibility
+        return super.get();
     }
 
     @Override
     public boolean put(Boolean value) {
-        return Main.pref.put(getKey(), value);
+        // Removing this implementation breaks binary compatibility
+        return super.put(value);
+    }
+
+    @Override
+    protected Boolean fromString(String string) {
+        return Boolean.valueOf(string);
+    }
+
+    @Override
+    protected String toString(Boolean t) {
+        return t.toString();
     }
 }

trunk/src/org/openstreetmap/josm/data/preferences/CachedProperty.java

@@ -14 +14 @@
     protected CachedProperty(String key, String defaultValueAsString) {
         super(key, null);
-        Main.pref.addPreferenceChangeListener(this);
+        Main.pref.addKeyPreferenceChangeListener(key, this);
         this.defaultValueAsString = defaultValueAsString;
         updateValue();
@@ -61 +61 @@
 
     public String getAsString() {
-        return Main.pref.get(getKey(), getDefaultValueAsString());
+        return getPreferences().get(getKey(), getDefaultValueAsString());
     }
 

trunk/src/org/openstreetmap/josm/data/preferences/CollectionProperty.java

@@ -25 +25 @@
     @Override
     public Collection<String> get() {
-        return Main.pref.getCollection(getKey(), getDefaultValue());
+        return getPreferences().getCollection(getKey(), getDefaultValue());
     }
 
     @Override
     public boolean put(Collection<String> value) {
-        return Main.pref.putCollection(getKey(), value);
+        return getPreferences().putCollection(getKey(), value);
     }
 }

trunk/src/org/openstreetmap/josm/data/preferences/ColorProperty.java

@@ -5 +5 @@
 import java.util.Locale;
 
-import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.data.Preferences.ColorKey;
+import org.openstreetmap.josm.tools.ColorHelper;
 
 /**
@@ -12 +11 @@
  * @since 5464
  */
-public class ColorProperty extends AbstractProperty<Color> implements ColorKey {
+public class ColorProperty extends AbstractToStringProperty<Color> {
 
     private final String name;
+
+    /**
+     * Constructs a new {@code ColorProperty}.
+     * @param colName The color name
+     * @param defaultValue The default value as HTML string
+     */
+    public ColorProperty(String colName, String defaultValue) {
+        this(colName, ColorHelper.html2color(defaultValue));
+    }
 
     /**
@@ -24 +32 @@
         super(getColorKey(colName), defaultValue);
         this.name = colName;
-        if (Main.pref != null) {
-            get();
-        }
+        getPreferences().registerColor(getColorKey(colName), colName);
     }
 
     @Override
     public Color get() {
-        return Main.pref.getColor(this);
+        // Removing this implementation breaks binary compatibility due to the way generics work
+        return super.get();
     }
 
     @Override
     public boolean put(Color value) {
-        return Main.pref.putColor(getColorKey(name), value);
+        // Removing this implementation breaks binary compatibility due to the way generics work
+        return super.put(value);
+    }
+
+    @Override
+    protected Color fromString(String string) {
+        return ColorHelper.html2color(string);
+    }
+
+    @Override
+    protected String toString(Color t) {
+        return ColorHelper.color2html(t, true);
+    }
+
+    /**
+     * Gets a color of which the value can be set.
+     * @param colorName the name of the color.
+     * @return The child property that inherits this value if it is not set.
+     */
+    public AbstractToStringProperty<Color> getChildColor(String colorName) {
+        return getChildProperty(getColorKey(colorName));
+    }
+
+    /**
+     * Gets the name this color was registered with.
+     * @return The name.
+     */
+    public String getName() {
+        return name;
     }
 
@@ -45 +80 @@
      */
     public static String getColorKey(String colName) {
-        return colName == null ? null : colName.toLowerCase(Locale.ENGLISH).replaceAll("[^a-z0-9]+", ".");
+        return colName == null ? null : "color." + colName.toLowerCase(Locale.ENGLISH).replaceAll("[^a-z0-9]+", ".");
     }
 
     @Override
-    public String getColorName() {
-        return name;
-    }
-
-    @Override
-    public String getSpecialName() {
-        return null;
+    public String toString() {
+        return "ColorProperty [name=" + name + ", defaultValue=" + getDefaultValue() + "]";
     }
 }

trunk/src/org/openstreetmap/josm/data/preferences/DoubleProperty.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.preferences;
-
-import org.openstreetmap.josm.Main;
 
 /**
@@ -8 +6 @@
  * @since 3246
  */
-public class DoubleProperty extends AbstractProperty<Double> {
+public class DoubleProperty extends AbstractToStringProperty<Double> {
 
     /**
@@ -21 +19 @@
     @Override
     public Double get() {
-        return Main.pref.getDouble(getKey(), getDefaultValue());
+        // Removing this implementation breaks binary compatibility
+        return super.get();
     }
 
     @Override
     public boolean put(Double value) {
-        return Main.pref.putDouble(getKey(), value);
+        // Removing this implementation breaks binary compatibility
+        return super.put(value);
+    }
+
+    @Override
+    protected Double fromString(String string) {
+        try {
+            return Double.valueOf(string);
+        } catch (NumberFormatException e) {
+            throw new InvalidPreferenceValueException(e);
+        }
+    }
+
+    @Override
+    protected String toString(Double t) {
+        return t.toString();
     }
 

trunk/src/org/openstreetmap/josm/data/preferences/IntegerProperty.java

@@ -8 +8 @@
  * @since 3246
  */
-public class IntegerProperty extends AbstractProperty<Integer> {
+public class IntegerProperty extends AbstractToStringProperty<Integer> {
 
     /**
@@ -24 +24 @@
     @Override
     public Integer get() {
-        return Main.pref.getInteger(getKey(), getDefaultValue());
+        // Removing this implementation breaks binary compatibility
+        return super.get();
     }
 
     @Override
     public boolean put(Integer value) {
-        return Main.pref.putInteger(getKey(), value);
+        // Removing this implementation breaks binary compatibility
+        return super.put(value);
+    }
+
+    @Override
+    protected Integer fromString(String string) {
+        try {
+            return Integer.valueOf(string);
+        } catch (NumberFormatException e) {
+            throw new InvalidPreferenceValueException(e);
+        }
+    }
+
+    @Override
+    protected String toString(Integer t) {
+        return t.toString();
     }
 

trunk/src/org/openstreetmap/josm/data/preferences/LongProperty.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.preferences;
-
-import org.openstreetmap.josm.Main;
 
 /**
@@ -9 +7 @@
  *
  */
-public class LongProperty extends AbstractProperty<Long> {
+public class LongProperty extends AbstractToStringProperty<Long> {
 
     /**
@@ -18 +16 @@
     public LongProperty(String key, long defaultValue) {
         super(key, defaultValue);
-        if (Main.pref != null) {
-            get();
+    }
+
+    @Override
+    public Long get() {
+        // Removing this implementation breaks binary compatibility
+        return super.get();
+    }
+
+    @Override
+    public boolean put(Long value) {
+        // Removing this implementation breaks binary compatibility
+        return super.put(value);
+    }
+
+    @Override
+    protected Long fromString(String string) {
+        try {
+            return Long.valueOf(string);
+        } catch (NumberFormatException e) {
+            throw new InvalidPreferenceValueException(e);
         }
     }
 
     @Override
-    public Long get() {
-        return Main.pref.getLong(getKey(), getDefaultValue());
+    protected String toString(Long t) {
+        return t.toString();
     }
-
-    @Override
-    public boolean put(Long value) {
-        return Main.pref.putLong(getKey(), value);
-    }
-
 }

trunk/src/org/openstreetmap/josm/data/preferences/PreferencesWriter.java

@@ -6 +6 @@
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import org.openstreetmap.josm.Main;
@@ -38 +39 @@
      */
     public void write(Collection<Map.Entry<String, Setting<?>>> settings) {
+        write(settings.stream());
+    }
+
+    /**
+     * Write preferences.
+     *
+     * @param settings preferences settings to write as stream.
+     */
+    public void write(Stream<Map.Entry<String, Setting<?>>> settings) {
         out.write(String.format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>%n"));
         String rootElement = defaults ? "preferences-defaults" : "preferences";
@@ -45 +55 @@
         }
         out.write(String.format(" version='%d'>%n", Version.getInstance().getVersion()));
-        for (Map.Entry<String, Setting<?>> e : settings) {
+        settings.forEachOrdered(e -> {
             setKey(e.getKey());
             e.getValue().visit(this);
-        }
+        });
         out.write(String.format("</%s>%n", rootElement));
     }

trunk/src/org/openstreetmap/josm/data/preferences/StringProperty.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.preferences;
-
-import org.openstreetmap.josm.Main;
 
 /**
  * A property containing an {@code String} value.
  */
-public class StringProperty extends AbstractProperty<String> {
+public class StringProperty extends AbstractToStringProperty<String> {
 
     /**
@@ -16 +14 @@
     public StringProperty(String key, String defaultValue) {
         super(key, defaultValue);
-        if (Main.pref != null) {
-            get();
-        }
     }
 
     @Override
     public String get() {
-        return Main.pref.get(getKey(), getDefaultValue());
+        // Removing this implementation breaks binary compatibility
+        return super.get();
     }
 
     @Override
     public boolean put(String value) {
-        return Main.pref.put(getKey(), value);
+        // Removing this implementation breaks binary compatibility
+        return super.put(value);
+    }
+
+    @Override
+    protected String fromString(String string) {
+        return string;
+    }
+
+    @Override
+    protected String toString(String string) {
+        return string;
     }
 }