source: josm/trunk/src/org/openstreetmap/josm/data/Preferences.java @ 11461

Last change on this file since 11461 was 11461, checked in by Don-vip, 9 months ago

sonar - fb-contrib:SPP_USE_CONTAINSKEY - Style - Method calls keySet() just to call contains, use containsKey instead

  • Property svn:eol-style set to native
File size: 62.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data;
3
4import static org.openstreetmap.josm.tools.I18n.marktr;
5import static org.openstreetmap.josm.tools.I18n.tr;
6
7import java.awt.Color;
8import java.awt.GraphicsEnvironment;
9import java.awt.Toolkit;
10import java.io.File;
11import java.io.IOException;
12import java.io.PrintWriter;
13import java.io.Reader;
14import java.io.StringReader;
15import java.io.StringWriter;
16import java.lang.annotation.Retention;
17import java.lang.annotation.RetentionPolicy;
18import java.lang.reflect.Field;
19import java.nio.charset.StandardCharsets;
20import java.util.AbstractMap;
21import java.util.ArrayList;
22import java.util.Collection;
23import java.util.Collections;
24import java.util.HashMap;
25import java.util.HashSet;
26import java.util.Iterator;
27import java.util.LinkedHashMap;
28import java.util.LinkedList;
29import java.util.List;
30import java.util.Map;
31import java.util.Map.Entry;
32import java.util.Objects;
33import java.util.Optional;
34import java.util.ResourceBundle;
35import java.util.Set;
36import java.util.SortedMap;
37import java.util.TreeMap;
38import java.util.concurrent.TimeUnit;
39import java.util.function.Predicate;
40import java.util.regex.Matcher;
41import java.util.regex.Pattern;
42import java.util.stream.Collectors;
43import java.util.stream.Stream;
44
45import javax.json.Json;
46import javax.json.JsonArray;
47import javax.json.JsonArrayBuilder;
48import javax.json.JsonObject;
49import javax.json.JsonObjectBuilder;
50import javax.json.JsonReader;
51import javax.json.JsonString;
52import javax.json.JsonValue;
53import javax.json.JsonWriter;
54import javax.swing.JOptionPane;
55import javax.xml.stream.XMLStreamException;
56
57import org.openstreetmap.josm.Main;
58import org.openstreetmap.josm.data.preferences.BooleanProperty;
59import org.openstreetmap.josm.data.preferences.ColorProperty;
60import org.openstreetmap.josm.data.preferences.DoubleProperty;
61import org.openstreetmap.josm.data.preferences.IntegerProperty;
62import org.openstreetmap.josm.data.preferences.ListListSetting;
63import org.openstreetmap.josm.data.preferences.ListSetting;
64import org.openstreetmap.josm.data.preferences.LongProperty;
65import org.openstreetmap.josm.data.preferences.MapListSetting;
66import org.openstreetmap.josm.data.preferences.PreferencesReader;
67import org.openstreetmap.josm.data.preferences.PreferencesWriter;
68import org.openstreetmap.josm.data.preferences.Setting;
69import org.openstreetmap.josm.data.preferences.StringSetting;
70import org.openstreetmap.josm.gui.preferences.SourceEditor.ExtendedSourceEntry;
71import org.openstreetmap.josm.gui.preferences.validator.ValidatorTagCheckerRulesPreference;
72import org.openstreetmap.josm.gui.preferences.validator.ValidatorTagCheckerRulesPreference.RulePrefHelper;
73import org.openstreetmap.josm.io.OfflineAccessException;
74import org.openstreetmap.josm.io.OnlineResource;
75import org.openstreetmap.josm.tools.CheckParameterUtil;
76import org.openstreetmap.josm.tools.ColorHelper;
77import org.openstreetmap.josm.tools.I18n;
78import org.openstreetmap.josm.tools.JosmRuntimeException;
79import org.openstreetmap.josm.tools.ListenerList;
80import org.openstreetmap.josm.tools.MultiMap;
81import org.openstreetmap.josm.tools.Utils;
82import org.xml.sax.SAXException;
83
84/**
85 * This class holds all preferences for JOSM.
86 *
87 * Other classes can register their beloved properties here. All properties will be
88 * saved upon set-access.
89 *
90 * Each property is a key=setting pair, where key is a String and setting can be one of
91 * 4 types:
92 *     string, list, list of lists and list of maps.
93 * In addition, each key has a unique default value that is set when the value is first
94 * accessed using one of the get...() methods. You can use the same preference
95 * key in different parts of the code, but the default value must be the same
96 * everywhere. A default value of null means, the setting has been requested, but
97 * no default value was set. This is used in advanced preferences to present a list
98 * off all possible settings.
99 *
100 * At the moment, you cannot put the empty string for string properties.
101 * put(key, "") means, the property is removed.
102 *
103 * @author imi
104 * @since 74
105 */
106public class Preferences {
107
108    private static final String[] OBSOLETE_PREF_KEYS = {
109      "hdop.factor" /* remove entry after April 2017 */
110    };
111
112    private static final long MAX_AGE_DEFAULT_PREFERENCES = TimeUnit.DAYS.toSeconds(50);
113
114    /**
115     * Internal storage for the preference directory.
116     * Do not access this variable directly!
117     * @see #getPreferencesDirectory()
118     */
119    private File preferencesDir;
120
121    /**
122     * Internal storage for the cache directory.
123     */
124    private File cacheDir;
125
126    /**
127     * Internal storage for the user data directory.
128     */
129    private File userdataDir;
130
131    /**
132     * Determines if preferences file is saved each time a property is changed.
133     */
134    private boolean saveOnPut = true;
135
136    /**
137     * Maps the setting name to the current value of the setting.
138     * The map must not contain null as key or value. The mapped setting objects
139     * must not have a null value.
140     */
141    protected final SortedMap<String, Setting<?>> settingsMap = new TreeMap<>();
142
143    /**
144     * Maps the setting name to the default value of the setting.
145     * The map must not contain null as key or value. The value of the mapped
146     * setting objects can be null.
147     */
148    protected final SortedMap<String, Setting<?>> defaultsMap = new TreeMap<>();
149
150    private final Predicate<Entry<String, Setting<?>>> NO_DEFAULT_SETTINGS_ENTRY =
151            e -> !e.getValue().equals(defaultsMap.get(e.getKey()));
152
153    /**
154     * Maps color keys to human readable color name
155     */
156    protected final SortedMap<String, String> colornames = new TreeMap<>();
157
158    /**
159     * Indicates whether {@link #init(boolean)} completed successfully.
160     * Used to decide whether to write backup preference file in {@link #save()}
161     */
162    protected boolean initSuccessful;
163
164    /**
165     * Event triggered when a preference entry value changes.
166     */
167    public interface PreferenceChangeEvent {
168        /**
169         * Returns the preference key.
170         * @return the preference key
171         */
172        String getKey();
173
174        /**
175         * Returns the old preference value.
176         * @return the old preference value
177         */
178        Setting<?> getOldValue();
179
180        /**
181         * Returns the new preference value.
182         * @return the new preference value
183         */
184        Setting<?> getNewValue();
185    }
186
187    /**
188     * Listener to preference change events.
189     * @since 10600 (functional interface)
190     */
191    @FunctionalInterface
192    public interface PreferenceChangedListener {
193        /**
194         * Trigerred when a preference entry value changes.
195         * @param e the preference change event
196         */
197        void preferenceChanged(PreferenceChangeEvent e);
198    }
199
200    private static class DefaultPreferenceChangeEvent implements PreferenceChangeEvent {
201        private final String key;
202        private final Setting<?> oldValue;
203        private final Setting<?> newValue;
204
205        DefaultPreferenceChangeEvent(String key, Setting<?> oldValue, Setting<?> newValue) {
206            this.key = key;
207            this.oldValue = oldValue;
208            this.newValue = newValue;
209        }
210
211        @Override
212        public String getKey() {
213            return key;
214        }
215
216        @Override
217        public Setting<?> getOldValue() {
218            return oldValue;
219        }
220
221        @Override
222        public Setting<?> getNewValue() {
223            return newValue;
224        }
225    }
226
227    private final ListenerList<PreferenceChangedListener> listeners = ListenerList.create();
228
229    private final HashMap<String, ListenerList<PreferenceChangedListener>> keyListeners = new HashMap<>();
230
231    /**
232     * Adds a new preferences listener.
233     * @param listener The listener to add
234     */
235    public void addPreferenceChangeListener(PreferenceChangedListener listener) {
236        if (listener != null) {
237            listeners.addListener(listener);
238        }
239    }
240
241    /**
242     * Removes a preferences listener.
243     * @param listener The listener to remove
244     */
245    public void removePreferenceChangeListener(PreferenceChangedListener listener) {
246        listeners.removeListener(listener);
247    }
248
249    /**
250     * Adds a listener that only listens to changes in one preference
251     * @param key The preference key to listen to
252     * @param listener The listener to add.
253     * @since 10824
254     */
255    public void addKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
256        listenersForKey(key).addListener(listener);
257    }
258
259    /**
260     * Adds a weak listener that only listens to changes in one preference
261     * @param key The preference key to listen to
262     * @param listener The listener to add.
263     * @since 10824
264     */
265    public void addWeakKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
266        listenersForKey(key).addWeakListener(listener);
267    }
268
269    private ListenerList<PreferenceChangedListener> listenersForKey(String key) {
270        ListenerList<PreferenceChangedListener> keyListener = keyListeners.get(key);
271        if (keyListener == null) {
272            keyListener = ListenerList.create();
273            keyListeners.put(key, keyListener);
274        }
275        return keyListener;
276    }
277
278    /**
279     * Removes a listener that only listens to changes in one preference
280     * @param key The preference key to listen to
281     * @param listener The listener to add.
282     */
283    public void removeKeyPreferenceChangeListener(String key, PreferenceChangedListener listener) {
284        ListenerList<PreferenceChangedListener> keyListener = keyListeners.get(key);
285        if (keyListener == null) {
286            throw new IllegalArgumentException("There are no listeners registered for " + key);
287        }
288        keyListener.removeListener(listener);
289    }
290
291    protected void firePreferenceChanged(String key, Setting<?> oldValue, Setting<?> newValue) {
292        final PreferenceChangeEvent evt = new DefaultPreferenceChangeEvent(key, oldValue, newValue);
293        listeners.fireEvent(listener -> listener.preferenceChanged(evt));
294
295        ListenerList<PreferenceChangedListener> forKey = keyListeners.get(key);
296        if (forKey != null) {
297            forKey.fireEvent(listener -> listener.preferenceChanged(evt));
298        }
299    }
300
301    /**
302     * Get the base name of the JOSM directories for preferences, cache and
303     * user data.
304     * Default value is "JOSM", unless overridden by system property "josm.dir.name".
305     * @return the base name of the JOSM directories for preferences, cache and
306     * user data
307     */
308    public String getJOSMDirectoryBaseName() {
309        String name = System.getProperty("josm.dir.name");
310        if (name != null)
311            return name;
312        else
313            return "JOSM";
314    }
315
316    /**
317     * Returns the user defined preferences directory, containing the preferences.xml file
318     * @return The user defined preferences directory, containing the preferences.xml file
319     * @since 7834
320     */
321    public File getPreferencesDirectory() {
322        if (preferencesDir != null)
323            return preferencesDir;
324        String path;
325        path = System.getProperty("josm.pref");
326        if (path != null) {
327            preferencesDir = new File(path).getAbsoluteFile();
328        } else {
329            path = System.getProperty("josm.home");
330            if (path != null) {
331                preferencesDir = new File(path).getAbsoluteFile();
332            } else {
333                preferencesDir = Main.platform.getDefaultPrefDirectory();
334            }
335        }
336        return preferencesDir;
337    }
338
339    /**
340     * Returns the user data directory, containing autosave, plugins, etc.
341     * Depending on the OS it may be the same directory as preferences directory.
342     * @return The user data directory, containing autosave, plugins, etc.
343     * @since 7834
344     */
345    public File getUserDataDirectory() {
346        if (userdataDir != null)
347            return userdataDir;
348        String path;
349        path = System.getProperty("josm.userdata");
350        if (path != null) {
351            userdataDir = new File(path).getAbsoluteFile();
352        } else {
353            path = System.getProperty("josm.home");
354            if (path != null) {
355                userdataDir = new File(path).getAbsoluteFile();
356            } else {
357                userdataDir = Main.platform.getDefaultUserDataDirectory();
358            }
359        }
360        return userdataDir;
361    }
362
363    /**
364     * Returns the user preferences file (preferences.xml).
365     * @return The user preferences file (preferences.xml)
366     */
367    public File getPreferenceFile() {
368        return new File(getPreferencesDirectory(), "preferences.xml");
369    }
370
371    /**
372     * Returns the cache file for default preferences.
373     * @return the cache file for default preferences
374     */
375    public File getDefaultsCacheFile() {
376        return new File(getCacheDirectory(), "default_preferences.xml");
377    }
378
379    /**
380     * Returns the user plugin directory.
381     * @return The user plugin directory
382     */
383    public File getPluginsDirectory() {
384        return new File(getUserDataDirectory(), "plugins");
385    }
386
387    /**
388     * Get the directory where cached content of any kind should be stored.
389     *
390     * If the directory doesn't exist on the file system, it will be created by this method.
391     *
392     * @return the cache directory
393     */
394    public File getCacheDirectory() {
395        if (cacheDir != null)
396            return cacheDir;
397        String path = System.getProperty("josm.cache");
398        if (path != null) {
399            cacheDir = new File(path).getAbsoluteFile();
400        } else {
401            path = System.getProperty("josm.home");
402            if (path != null) {
403                cacheDir = new File(path, "cache");
404            } else {
405                path = get("cache.folder", null);
406                if (path != null) {
407                    cacheDir = new File(path).getAbsoluteFile();
408                } else {
409                    cacheDir = Main.platform.getDefaultCacheDirectory();
410                }
411            }
412        }
413        if (!cacheDir.exists() && !cacheDir.mkdirs()) {
414            Main.warn(tr("Failed to create missing cache directory: {0}", cacheDir.getAbsoluteFile()));
415            JOptionPane.showMessageDialog(
416                    Main.parent,
417                    tr("<html>Failed to create missing cache directory: {0}</html>", cacheDir.getAbsoluteFile()),
418                    tr("Error"),
419                    JOptionPane.ERROR_MESSAGE
420            );
421        }
422        return cacheDir;
423    }
424
425    private static void addPossibleResourceDir(Set<String> locations, String s) {
426        if (s != null) {
427            if (!s.endsWith(File.separator)) {
428                s += File.separator;
429            }
430            locations.add(s);
431        }
432    }
433
434    /**
435     * Returns a set of all existing directories where resources could be stored.
436     * @return A set of all existing directories where resources could be stored.
437     */
438    public Collection<String> getAllPossiblePreferenceDirs() {
439        Set<String> locations = new HashSet<>();
440        addPossibleResourceDir(locations, getPreferencesDirectory().getPath());
441        addPossibleResourceDir(locations, getUserDataDirectory().getPath());
442        addPossibleResourceDir(locations, System.getenv("JOSM_RESOURCES"));
443        addPossibleResourceDir(locations, System.getProperty("josm.resources"));
444        if (Main.isPlatformWindows()) {
445            String appdata = System.getenv("APPDATA");
446            if (appdata != null && System.getenv("ALLUSERSPROFILE") != null
447                    && appdata.lastIndexOf(File.separator) != -1) {
448                appdata = appdata.substring(appdata.lastIndexOf(File.separator));
449                locations.add(new File(new File(System.getenv("ALLUSERSPROFILE"),
450                        appdata), "JOSM").getPath());
451            }
452        } else {
453            locations.add("/usr/local/share/josm/");
454            locations.add("/usr/local/lib/josm/");
455            locations.add("/usr/share/josm/");
456            locations.add("/usr/lib/josm/");
457        }
458        return locations;
459    }
460
461    /**
462     * Get settings value for a certain key.
463     * @param key the identifier for the setting
464     * @return "" if there is nothing set for the preference key, the corresponding value otherwise. The result is not null.
465     */
466    public synchronized String get(final String key) {
467        String value = get(key, null);
468        return value == null ? "" : value;
469    }
470
471    /**
472     * Get settings value for a certain key and provide default a value.
473     * @param key the identifier for the setting
474     * @param def the default value. For each call of get() with a given key, the default value must be the same.
475     * @return the corresponding value if the property has been set before, {@code def} otherwise
476     */
477    public synchronized String get(final String key, final String def) {
478        return getSetting(key, new StringSetting(def), StringSetting.class).getValue();
479    }
480
481    public synchronized Map<String, String> getAllPrefix(final String prefix) {
482        final Map<String, String> all = new TreeMap<>();
483        for (final Entry<String, Setting<?>> e : settingsMap.entrySet()) {
484            if (e.getKey().startsWith(prefix) && (e.getValue() instanceof StringSetting)) {
485                all.put(e.getKey(), ((StringSetting) e.getValue()).getValue());
486            }
487        }
488        return all;
489    }
490
491    public synchronized List<String> getAllPrefixCollectionKeys(final String prefix) {
492        final List<String> all = new LinkedList<>();
493        for (Map.Entry<String, Setting<?>> entry : settingsMap.entrySet()) {
494            if (entry.getKey().startsWith(prefix) && entry.getValue() instanceof ListSetting) {
495                all.add(entry.getKey());
496            }
497        }
498        return all;
499    }
500
501    public synchronized Map<String, String> getAllColors() {
502        final Map<String, String> all = new TreeMap<>();
503        for (final Entry<String, Setting<?>> e : defaultsMap.entrySet()) {
504            if (e.getKey().startsWith("color.") && e.getValue() instanceof StringSetting) {
505                StringSetting d = (StringSetting) e.getValue();
506                if (d.getValue() != null) {
507                    all.put(e.getKey().substring(6), d.getValue());
508                }
509            }
510        }
511        for (final Entry<String, Setting<?>> e : settingsMap.entrySet()) {
512            if (e.getKey().startsWith("color.") && (e.getValue() instanceof StringSetting)) {
513                all.put(e.getKey().substring(6), ((StringSetting) e.getValue()).getValue());
514            }
515        }
516        return all;
517    }
518
519    public synchronized boolean getBoolean(final String key) {
520        String s = get(key, null);
521        return s != null && Boolean.parseBoolean(s);
522    }
523
524    public synchronized boolean getBoolean(final String key, final boolean def) {
525        return Boolean.parseBoolean(get(key, Boolean.toString(def)));
526    }
527
528    public synchronized boolean getBoolean(final String key, final String specName, final boolean def) {
529        boolean generic = getBoolean(key, def);
530        String skey = key+'.'+specName;
531        Setting<?> prop = settingsMap.get(skey);
532        if (prop instanceof StringSetting)
533            return Boolean.parseBoolean(((StringSetting) prop).getValue());
534        else
535            return generic;
536    }
537
538    /**
539     * Set a value for a certain setting.
540     * @param key the unique identifier for the setting
541     * @param value the value of the setting. Can be null or "" which both removes the key-value entry.
542     * @return {@code true}, if something has changed (i.e. value is different than before)
543     */
544    public boolean put(final String key, String value) {
545        return putSetting(key, value == null || value.isEmpty() ? null : new StringSetting(value));
546    }
547
548    /**
549     * Set a boolean value for a certain setting.
550     * @param key the unique identifier for the setting
551     * @param value The new value
552     * @return {@code true}, if something has changed (i.e. value is different than before)
553     * @see BooleanProperty
554     */
555    public boolean put(final String key, final boolean value) {
556        return put(key, Boolean.toString(value));
557    }
558
559    /**
560     * Set a boolean value for a certain setting.
561     * @param key the unique identifier for the setting
562     * @param value The new value
563     * @return {@code true}, if something has changed (i.e. value is different than before)
564     * @see IntegerProperty
565     */
566    public boolean putInteger(final String key, final Integer value) {
567        return put(key, Integer.toString(value));
568    }
569
570    /**
571     * Set a boolean value for a certain setting.
572     * @param key the unique identifier for the setting
573     * @param value The new value
574     * @return {@code true}, if something has changed (i.e. value is different than before)
575     * @see DoubleProperty
576     */
577    public boolean putDouble(final String key, final Double value) {
578        return put(key, Double.toString(value));
579    }
580
581    /**
582     * Set a boolean value for a certain setting.
583     * @param key the unique identifier for the setting
584     * @param value The new value
585     * @return {@code true}, if something has changed (i.e. value is different than before)
586     * @see LongProperty
587     */
588    public boolean putLong(final String key, final Long value) {
589        return put(key, Long.toString(value));
590    }
591
592    /**
593     * Called after every put. In case of a problem, do nothing but output the error in log.
594     * @throws IOException if any I/O error occurs
595     */
596    public synchronized void save() throws IOException {
597        save(getPreferenceFile(), settingsMap.entrySet().stream().filter(NO_DEFAULT_SETTINGS_ENTRY), false);
598    }
599
600    public synchronized void saveDefaults() throws IOException {
601        save(getDefaultsCacheFile(), defaultsMap.entrySet().stream(), true);
602    }
603
604    protected void save(File prefFile, Stream<Entry<String, Setting<?>>> settings, boolean defaults) throws IOException {
605        if (!defaults) {
606            /* currently unused, but may help to fix configuration issues in future */
607            putInteger("josm.version", Version.getInstance().getVersion());
608
609            updateSystemProperties();
610        }
611
612        File backupFile = new File(prefFile + "_backup");
613
614        // Backup old preferences if there are old preferences
615        if (initSuccessful && prefFile.exists() && prefFile.length() > 0) {
616            Utils.copyFile(prefFile, backupFile);
617        }
618
619        try (PreferencesWriter writer = new PreferencesWriter(
620                new PrintWriter(new File(prefFile + "_tmp"), StandardCharsets.UTF_8.name()), false, defaults)) {
621            writer.write(settings);
622        }
623
624        File tmpFile = new File(prefFile + "_tmp");
625        Utils.copyFile(tmpFile, prefFile);
626        Utils.deleteFile(tmpFile, marktr("Unable to delete temporary file {0}"));
627
628        setCorrectPermissions(prefFile);
629        setCorrectPermissions(backupFile);
630    }
631
632    private static void setCorrectPermissions(File file) {
633        if (!file.setReadable(false, false) && Main.isDebugEnabled()) {
634            Main.debug(tr("Unable to set file non-readable {0}", file.getAbsolutePath()));
635        }
636        if (!file.setWritable(false, false) && Main.isDebugEnabled()) {
637            Main.debug(tr("Unable to set file non-writable {0}", file.getAbsolutePath()));
638        }
639        if (!file.setExecutable(false, false) && Main.isDebugEnabled()) {
640            Main.debug(tr("Unable to set file non-executable {0}", file.getAbsolutePath()));
641        }
642        if (!file.setReadable(true, true) && Main.isDebugEnabled()) {
643            Main.debug(tr("Unable to set file readable {0}", file.getAbsolutePath()));
644        }
645        if (!file.setWritable(true, true) && Main.isDebugEnabled()) {
646            Main.debug(tr("Unable to set file writable {0}", file.getAbsolutePath()));
647        }
648    }
649
650    /**
651     * Loads preferences from settings file.
652     * @throws IOException if any I/O error occurs while reading the file
653     * @throws SAXException if the settings file does not contain valid XML
654     * @throws XMLStreamException if an XML error occurs while parsing the file (after validation)
655     */
656    protected void load() throws IOException, SAXException, XMLStreamException {
657        File pref = getPreferenceFile();
658        PreferencesReader.validateXML(pref);
659        PreferencesReader reader = new PreferencesReader(pref, false);
660        reader.parse();
661        settingsMap.clear();
662        settingsMap.putAll(reader.getSettings());
663        updateSystemProperties();
664        removeObsolete(reader.getVersion());
665    }
666
667    /**
668     * Loads default preferences from default settings cache file.
669     *
670     * Discards entries older than {@link #MAX_AGE_DEFAULT_PREFERENCES}.
671     *
672     * @throws IOException if any I/O error occurs while reading the file
673     * @throws SAXException if the settings file does not contain valid XML
674     * @throws XMLStreamException if an XML error occurs while parsing the file (after validation)
675     */
676    protected void loadDefaults() throws IOException, XMLStreamException, SAXException {
677        File def = getDefaultsCacheFile();
678        PreferencesReader.validateXML(def);
679        PreferencesReader reader = new PreferencesReader(def, true);
680        reader.parse();
681        defaultsMap.clear();
682        long minTime = System.currentTimeMillis() / 1000 - MAX_AGE_DEFAULT_PREFERENCES;
683        for (Entry<String, Setting<?>> e : reader.getSettings().entrySet()) {
684            if (e.getValue().getTime() >= minTime) {
685                defaultsMap.put(e.getKey(), e.getValue());
686            }
687        }
688    }
689
690    /**
691     * Loads preferences from XML reader.
692     * @param in XML reader
693     * @throws XMLStreamException if any XML stream error occurs
694     * @throws IOException if any I/O error occurs
695     */
696    public void fromXML(Reader in) throws XMLStreamException, IOException {
697        PreferencesReader reader = new PreferencesReader(in, false);
698        reader.parse();
699        settingsMap.clear();
700        settingsMap.putAll(reader.getSettings());
701    }
702
703    /**
704     * Initializes preferences.
705     * @param reset if {@code true}, current settings file is replaced by the default one
706     */
707    public void init(boolean reset) {
708        initSuccessful = false;
709        // get the preferences.
710        File prefDir = getPreferencesDirectory();
711        if (prefDir.exists()) {
712            if (!prefDir.isDirectory()) {
713                Main.warn(tr("Failed to initialize preferences. Preference directory ''{0}'' is not a directory.",
714                        prefDir.getAbsoluteFile()));
715                JOptionPane.showMessageDialog(
716                        Main.parent,
717                        tr("<html>Failed to initialize preferences.<br>Preference directory ''{0}'' is not a directory.</html>",
718                                prefDir.getAbsoluteFile()),
719                        tr("Error"),
720                        JOptionPane.ERROR_MESSAGE
721                );
722                return;
723            }
724        } else {
725            if (!prefDir.mkdirs()) {
726                Main.warn(tr("Failed to initialize preferences. Failed to create missing preference directory: {0}",
727                        prefDir.getAbsoluteFile()));
728                JOptionPane.showMessageDialog(
729                        Main.parent,
730                        tr("<html>Failed to initialize preferences.<br>Failed to create missing preference directory: {0}</html>",
731                                prefDir.getAbsoluteFile()),
732                        tr("Error"),
733                        JOptionPane.ERROR_MESSAGE
734                );
735                return;
736            }
737        }
738
739        File preferenceFile = getPreferenceFile();
740        try {
741            if (!preferenceFile.exists()) {
742                Main.info(tr("Missing preference file ''{0}''. Creating a default preference file.", preferenceFile.getAbsoluteFile()));
743                resetToDefault();
744                save();
745            } else if (reset) {
746                File backupFile = new File(prefDir, "preferences.xml.bak");
747                Main.platform.rename(preferenceFile, backupFile);
748                Main.warn(tr("Replacing existing preference file ''{0}'' with default preference file.", preferenceFile.getAbsoluteFile()));
749                resetToDefault();
750                save();
751            }
752        } catch (IOException e) {
753            Main.error(e);
754            JOptionPane.showMessageDialog(
755                    Main.parent,
756                    tr("<html>Failed to initialize preferences.<br>Failed to reset preference file to default: {0}</html>",
757                            getPreferenceFile().getAbsoluteFile()),
758                    tr("Error"),
759                    JOptionPane.ERROR_MESSAGE
760            );
761            return;
762        }
763        try {
764            load();
765            initSuccessful = true;
766        } catch (IOException | SAXException | XMLStreamException e) {
767            Main.error(e);
768            File backupFile = new File(prefDir, "preferences.xml.bak");
769            JOptionPane.showMessageDialog(
770                    Main.parent,
771                    tr("<html>Preferences file had errors.<br> Making backup of old one to <br>{0}<br> " +
772                            "and creating a new default preference file.</html>",
773                            backupFile.getAbsoluteFile()),
774                    tr("Error"),
775                    JOptionPane.ERROR_MESSAGE
776            );
777            Main.platform.rename(preferenceFile, backupFile);
778            try {
779                resetToDefault();
780                save();
781            } catch (IOException e1) {
782                Main.error(e1);
783                Main.warn(tr("Failed to initialize preferences. Failed to reset preference file to default: {0}", getPreferenceFile()));
784            }
785        }
786        File def = getDefaultsCacheFile();
787        if (def.exists()) {
788            try {
789                loadDefaults();
790            } catch (IOException | XMLStreamException | SAXException e) {
791                Main.error(e);
792                Main.warn(tr("Failed to load defaults cache file: {0}", def));
793                defaultsMap.clear();
794                if (!def.delete()) {
795                    Main.warn(tr("Failed to delete faulty defaults cache file: {0}", def));
796                }
797            }
798        }
799    }
800
801    /**
802     * Resets the preferences to their initial state. This resets all values and file associations.
803     * The default values and listeners are not removed.
804     * <p>
805     * It is meant to be called before {@link #init(boolean)}
806     * @since 10876
807     */
808    public void resetToInitialState() {
809        resetToDefault();
810        preferencesDir = null;
811        cacheDir = null;
812        userdataDir = null;
813        saveOnPut = true;
814        initSuccessful = false;
815    }
816
817    /**
818     * Reset all values stored in this map to the default values. This clears the preferences.
819     */
820    public final void resetToDefault() {
821        settingsMap.clear();
822    }
823
824    /**
825     * Convenience method for accessing colour preferences.
826     * <p>
827     * To be removed: end of 2016
828     *
829     * @param colName name of the colour
830     * @param def default value
831     * @return a Color object for the configured colour, or the default value if none configured.
832     * @deprecated Use a {@link ColorProperty} instead.
833     */
834    @Deprecated
835    public synchronized Color getColor(String colName, Color def) {
836        return getColor(colName, null, def);
837    }
838
839    /* only for preferences */
840    public synchronized String getColorName(String o) {
841        Matcher m = Pattern.compile("mappaint\\.(.+?)\\.(.+)").matcher(o);
842        if (m.matches()) {
843            return tr("Paint style {0}: {1}", tr(I18n.escape(m.group(1))), tr(I18n.escape(m.group(2))));
844        }
845        m = Pattern.compile("layer (.+)").matcher(o);
846        if (m.matches()) {
847            return tr("Layer: {0}", tr(I18n.escape(m.group(1))));
848        }
849        return tr(I18n.escape(colornames.containsKey(o) ? colornames.get(o) : o));
850    }
851
852    /**
853     * Convenience method for accessing colour preferences.
854     * <p>
855     * To be removed: end of 2016
856     * @param colName name of the colour
857     * @param specName name of the special colour settings
858     * @param def default value
859     * @return a Color object for the configured colour, or the default value if none configured.
860     * @deprecated Use a {@link ColorProperty} instead.
861     * You can replace this by: <code>new ColorProperty(colName, def).getChildColor(specName)</code>
862     */
863    @Deprecated
864    public synchronized Color getColor(String colName, String specName, Color def) {
865        String colKey = ColorProperty.getColorKey(colName);
866        registerColor(colKey, colName);
867        String colStr = specName != null ? get("color."+specName) : "";
868        if (colStr.isEmpty()) {
869            colStr = get(colKey, ColorHelper.color2html(def, true));
870        }
871        if (colStr != null && !colStr.isEmpty()) {
872            return ColorHelper.html2color(colStr);
873        } else {
874            return def;
875        }
876    }
877
878    /**
879     * Registers a color name conversion for the global color registry.
880     * @param colKey The key
881     * @param colName The name of the color.
882     * @since 10824
883     */
884    public void registerColor(String colKey, String colName) {
885        if (!colKey.equals(colName)) {
886            colornames.put(colKey, colName);
887        }
888    }
889
890    public synchronized Color getDefaultColor(String colKey) {
891        StringSetting col = Utils.cast(defaultsMap.get("color."+colKey), StringSetting.class);
892        String colStr = col == null ? null : col.getValue();
893        return colStr == null || colStr.isEmpty() ? null : ColorHelper.html2color(colStr);
894    }
895
896    public synchronized boolean putColor(String colKey, Color val) {
897        return put("color."+colKey, val != null ? ColorHelper.color2html(val, true) : null);
898    }
899
900    public synchronized int getInteger(String key, int def) {
901        String v = get(key, Integer.toString(def));
902        if (v.isEmpty())
903            return def;
904
905        try {
906            return Integer.parseInt(v);
907        } catch (NumberFormatException e) {
908            // fall out
909            Main.trace(e);
910        }
911        return def;
912    }
913
914    public synchronized int getInteger(String key, String specName, int def) {
915        String v = get(key+'.'+specName);
916        if (v.isEmpty())
917            v = get(key, Integer.toString(def));
918        if (v.isEmpty())
919            return def;
920
921        try {
922            return Integer.parseInt(v);
923        } catch (NumberFormatException e) {
924            // fall out
925            Main.trace(e);
926        }
927        return def;
928    }
929
930    public synchronized long getLong(String key, long def) {
931        String v = get(key, Long.toString(def));
932        if (null == v)
933            return def;
934
935        try {
936            return Long.parseLong(v);
937        } catch (NumberFormatException e) {
938            // fall out
939            Main.trace(e);
940        }
941        return def;
942    }
943
944    public synchronized double getDouble(String key, double def) {
945        String v = get(key, Double.toString(def));
946        if (null == v)
947            return def;
948
949        try {
950            return Double.parseDouble(v);
951        } catch (NumberFormatException e) {
952            // fall out
953            Main.trace(e);
954        }
955        return def;
956    }
957
958    /**
959     * Get a list of values for a certain key
960     * @param key the identifier for the setting
961     * @param def the default value.
962     * @return the corresponding value if the property has been set before, {@code def} otherwise
963     */
964    public Collection<String> getCollection(String key, Collection<String> def) {
965        return getSetting(key, ListSetting.create(def), ListSetting.class).getValue();
966    }
967
968    /**
969     * Get a list of values for a certain key
970     * @param key the identifier for the setting
971     * @return the corresponding value if the property has been set before, an empty collection otherwise.
972     */
973    public Collection<String> getCollection(String key) {
974        Collection<String> val = getCollection(key, null);
975        return val == null ? Collections.<String>emptyList() : val;
976    }
977
978    public synchronized void removeFromCollection(String key, String value) {
979        List<String> a = new ArrayList<>(getCollection(key, Collections.<String>emptyList()));
980        a.remove(value);
981        putCollection(key, a);
982    }
983
984    /**
985     * Set a value for a certain setting. The changed setting is saved to the preference file immediately.
986     * Due to caching mechanisms on modern operating systems and hardware, this shouldn't be a performance problem.
987     * @param key the unique identifier for the setting
988     * @param setting the value of the setting. In case it is null, the key-value entry will be removed.
989     * @return {@code true}, if something has changed (i.e. value is different than before)
990     */
991    public boolean putSetting(final String key, Setting<?> setting) {
992        CheckParameterUtil.ensureParameterNotNull(key);
993        if (setting != null && setting.getValue() == null)
994            throw new IllegalArgumentException("setting argument must not have null value");
995        Setting<?> settingOld;
996        Setting<?> settingCopy = null;
997        synchronized (this) {
998            if (setting == null) {
999                settingOld = settingsMap.remove(key);
1000                if (settingOld == null)
1001                    return false;
1002            } else {
1003                settingOld = settingsMap.get(key);
1004                if (setting.equals(settingOld))
1005                    return false;
1006                if (settingOld == null && setting.equals(defaultsMap.get(key)))
1007                    return false;
1008                settingCopy = setting.copy();
1009                settingsMap.put(key, settingCopy);
1010            }
1011            if (saveOnPut) {
1012                try {
1013                    save();
1014                } catch (IOException e) {
1015                    Main.warn(e, tr("Failed to persist preferences to ''{0}''", getPreferenceFile().getAbsoluteFile()));
1016                }
1017            }
1018        }
1019        // Call outside of synchronized section in case some listener wait for other thread that wait for preference lock
1020        firePreferenceChanged(key, settingOld, settingCopy);
1021        return true;
1022    }
1023
1024    public synchronized Setting<?> getSetting(String key, Setting<?> def) {
1025        return getSetting(key, def, Setting.class);
1026    }
1027
1028    /**
1029     * Get settings value for a certain key and provide default a value.
1030     * @param <T> the setting type
1031     * @param key the identifier for the setting
1032     * @param def the default value. For each call of getSetting() with a given key, the default value must be the same.
1033     * <code>def</code> must not be null, but the value of <code>def</code> can be null.
1034     * @param klass the setting type (same as T)
1035     * @return the corresponding value if the property has been set before, {@code def} otherwise
1036     */
1037    @SuppressWarnings("unchecked")
1038    public synchronized <T extends Setting<?>> T getSetting(String key, T def, Class<T> klass) {
1039        CheckParameterUtil.ensureParameterNotNull(key);
1040        CheckParameterUtil.ensureParameterNotNull(def);
1041        Setting<?> oldDef = defaultsMap.get(key);
1042        if (oldDef != null && oldDef.isNew() && oldDef.getValue() != null && def.getValue() != null && !def.equals(oldDef)) {
1043            Main.info("Defaults for " + key + " differ: " + def + " != " + defaultsMap.get(key));
1044        }
1045        if (def.getValue() != null || oldDef == null) {
1046            Setting<?> defCopy = def.copy();
1047            defCopy.setTime(System.currentTimeMillis() / 1000);
1048            defCopy.setNew(true);
1049            defaultsMap.put(key, defCopy);
1050        }
1051        Setting<?> prop = settingsMap.get(key);
1052        if (klass.isInstance(prop)) {
1053            return (T) prop;
1054        } else {
1055            return def;
1056        }
1057    }
1058
1059    /**
1060     * Put a collection.
1061     * @param key key
1062     * @param value value
1063     * @return {@code true}, if something has changed (i.e. value is different than before)
1064     */
1065    public boolean putCollection(String key, Collection<String> value) {
1066        return putSetting(key, value == null ? null : ListSetting.create(value));
1067    }
1068
1069    /**
1070     * Saves at most {@code maxsize} items of collection {@code val}.
1071     * @param key key
1072     * @param maxsize max number of items to save
1073     * @param val value
1074     * @return {@code true}, if something has changed (i.e. value is different than before)
1075     */
1076    public boolean putCollectionBounded(String key, int maxsize, Collection<String> val) {
1077        Collection<String> newCollection = new ArrayList<>(Math.min(maxsize, val.size()));
1078        for (String i : val) {
1079            if (newCollection.size() >= maxsize) {
1080                break;
1081            }
1082            newCollection.add(i);
1083        }
1084        return putCollection(key, newCollection);
1085    }
1086
1087    /**
1088     * Used to read a 2-dimensional array of strings from the preference file.
1089     * If not a single entry could be found, <code>def</code> is returned.
1090     * @param key preference key
1091     * @param def default array value
1092     * @return array value
1093     */
1094    @SuppressWarnings({ "unchecked", "rawtypes" })
1095    public synchronized Collection<Collection<String>> getArray(String key, Collection<Collection<String>> def) {
1096        ListListSetting val = getSetting(key, ListListSetting.create(def), ListListSetting.class);
1097        return (Collection) val.getValue();
1098    }
1099
1100    public Collection<Collection<String>> getArray(String key) {
1101        Collection<Collection<String>> res = getArray(key, null);
1102        return res == null ? Collections.<Collection<String>>emptyList() : res;
1103    }
1104
1105    /**
1106     * Put an array.
1107     * @param key key
1108     * @param value value
1109     * @return {@code true}, if something has changed (i.e. value is different than before)
1110     */
1111    public boolean putArray(String key, Collection<Collection<String>> value) {
1112        return putSetting(key, value == null ? null : ListListSetting.create(value));
1113    }
1114
1115    public Collection<Map<String, String>> getListOfStructs(String key, Collection<Map<String, String>> def) {
1116        return getSetting(key, new MapListSetting(def == null ? null : new ArrayList<>(def)), MapListSetting.class).getValue();
1117    }
1118
1119    public boolean putListOfStructs(String key, Collection<Map<String, String>> value) {
1120        return putSetting(key, value == null ? null : new MapListSetting(new ArrayList<>(value)));
1121    }
1122
1123    /**
1124     * Annotation used for converting objects to String Maps and vice versa.
1125     * Indicates that a certain field should be considered in the conversion process. Otherwise it is ignored.
1126     *
1127     * @see #serializeStruct(java.lang.Object, java.lang.Class)
1128     * @see #deserializeStruct(java.util.Map, java.lang.Class)
1129     */
1130    @Retention(RetentionPolicy.RUNTIME) // keep annotation at runtime
1131    public @interface pref { }
1132
1133    /**
1134     * Annotation used for converting objects to String Maps.
1135     * Indicates that a certain field should be written to the map, even if the value is the same as the default value.
1136     *
1137     * @see #serializeStruct(java.lang.Object, java.lang.Class)
1138     */
1139    @Retention(RetentionPolicy.RUNTIME) // keep annotation at runtime
1140    public @interface writeExplicitly { }
1141
1142    /**
1143     * Get a list of hashes which are represented by a struct-like class.
1144     * Possible properties are given by fields of the class klass that have the @pref annotation.
1145     * Default constructor is used to initialize the struct objects, properties then override some of these default values.
1146     * @param <T> klass type
1147     * @param key main preference key
1148     * @param klass The struct class
1149     * @return a list of objects of type T or an empty list if nothing was found
1150     */
1151    public <T> List<T> getListOfStructs(String key, Class<T> klass) {
1152        List<T> r = getListOfStructs(key, null, klass);
1153        if (r == null)
1154            return Collections.emptyList();
1155        else
1156            return r;
1157    }
1158
1159    /**
1160     * same as above, but returns def if nothing was found
1161     * @param <T> klass type
1162     * @param key main preference key
1163     * @param def default value
1164     * @param klass The struct class
1165     * @return a list of objects of type T or {@code def} if nothing was found
1166     */
1167    public <T> List<T> getListOfStructs(String key, Collection<T> def, Class<T> klass) {
1168        Collection<Map<String, String>> prop =
1169            getListOfStructs(key, def == null ? null : serializeListOfStructs(def, klass));
1170        if (prop == null)
1171            return def == null ? null : new ArrayList<>(def);
1172        List<T> lst = new ArrayList<>();
1173        for (Map<String, String> entries : prop) {
1174            T struct = deserializeStruct(entries, klass);
1175            lst.add(struct);
1176        }
1177        return lst;
1178    }
1179
1180    /**
1181     * Convenience method that saves a MapListSetting which is provided as a collection of objects.
1182     *
1183     * Each object is converted to a <code>Map&lt;String, String&gt;</code> using the fields with {@link pref} annotation.
1184     * The field name is the key and the value will be converted to a string.
1185     *
1186     * Considers only fields that have the @pref annotation.
1187     * In addition it does not write fields with null values. (Thus they are cleared)
1188     * Default values are given by the field values after default constructor has been called.
1189     * Fields equal to the default value are not written unless the field has the @writeExplicitly annotation.
1190     * @param <T> the class,
1191     * @param key main preference key
1192     * @param val the list that is supposed to be saved
1193     * @param klass The struct class
1194     * @return true if something has changed
1195     */
1196    public <T> boolean putListOfStructs(String key, Collection<T> val, Class<T> klass) {
1197        return putListOfStructs(key, serializeListOfStructs(val, klass));
1198    }
1199
1200    private static <T> Collection<Map<String, String>> serializeListOfStructs(Collection<T> l, Class<T> klass) {
1201        if (l == null)
1202            return null;
1203        Collection<Map<String, String>> vals = new ArrayList<>();
1204        for (T struct : l) {
1205            if (struct == null) {
1206                continue;
1207            }
1208            vals.add(serializeStruct(struct, klass));
1209        }
1210        return vals;
1211    }
1212
1213    @SuppressWarnings("rawtypes")
1214    private static String mapToJson(Map map) {
1215        StringWriter stringWriter = new StringWriter();
1216        try (JsonWriter writer = Json.createWriter(stringWriter)) {
1217            JsonObjectBuilder object = Json.createObjectBuilder();
1218            for (Object o: map.entrySet()) {
1219                Entry e = (Entry) o;
1220                Object evalue = e.getValue();
1221                object.add(e.getKey().toString(), evalue.toString());
1222            }
1223            writer.writeObject(object.build());
1224        }
1225        return stringWriter.toString();
1226    }
1227
1228    @SuppressWarnings({ "rawtypes", "unchecked" })
1229    private static Map mapFromJson(String s) {
1230        Map ret = null;
1231        try (JsonReader reader = Json.createReader(new StringReader(s))) {
1232            JsonObject object = reader.readObject();
1233            ret = new HashMap(object.size());
1234            for (Entry<String, JsonValue> e: object.entrySet()) {
1235                JsonValue value = e.getValue();
1236                if (value instanceof JsonString) {
1237                    // in some cases, when JsonValue.toString() is called, then additional quotation marks are left in value
1238                    ret.put(e.getKey(), ((JsonString) value).getString());
1239                } else {
1240                    ret.put(e.getKey(), e.getValue().toString());
1241                }
1242            }
1243        }
1244        return ret;
1245    }
1246
1247    @SuppressWarnings("rawtypes")
1248    private static String multiMapToJson(MultiMap map) {
1249        StringWriter stringWriter = new StringWriter();
1250        try (JsonWriter writer = Json.createWriter(stringWriter)) {
1251            JsonObjectBuilder object = Json.createObjectBuilder();
1252            for (Object o: map.entrySet()) {
1253                Entry e = (Entry) o;
1254                Set evalue = (Set) e.getValue();
1255                JsonArrayBuilder a = Json.createArrayBuilder();
1256                for (Object evo: evalue) {
1257                    a.add(evo.toString());
1258                }
1259                object.add(e.getKey().toString(), a.build());
1260            }
1261            writer.writeObject(object.build());
1262        }
1263        return stringWriter.toString();
1264    }
1265
1266    @SuppressWarnings({ "rawtypes", "unchecked" })
1267    private static MultiMap multiMapFromJson(String s) {
1268        MultiMap ret = null;
1269        try (JsonReader reader = Json.createReader(new StringReader(s))) {
1270            JsonObject object = reader.readObject();
1271            ret = new MultiMap(object.size());
1272            for (Entry<String, JsonValue> e: object.entrySet()) {
1273                JsonValue value = e.getValue();
1274                if (value instanceof JsonArray) {
1275                    for (JsonString js: ((JsonArray) value).getValuesAs(JsonString.class)) {
1276                        ret.put(e.getKey(), js.getString());
1277                    }
1278                } else if (value instanceof JsonString) {
1279                    // in some cases, when JsonValue.toString() is called, then additional quotation marks are left in value
1280                    ret.put(e.getKey(), ((JsonString) value).getString());
1281                } else {
1282                    ret.put(e.getKey(), e.getValue().toString());
1283                }
1284            }
1285        }
1286        return ret;
1287    }
1288
1289    /**
1290     * Convert an object to a String Map, by using field names and values as map key and value.
1291     *
1292     * The field value is converted to a String.
1293     *
1294     * Only fields with annotation {@link pref} are taken into account.
1295     *
1296     * Fields will not be written to the map if the value is null or unchanged
1297     * (compared to an object created with the no-arg-constructor).
1298     * The {@link writeExplicitly} annotation overrides this behavior, i.e. the default value will also be written.
1299     *
1300     * @param <T> the class of the object <code>struct</code>
1301     * @param struct the object to be converted
1302     * @param klass the class T
1303     * @return the resulting map (same data content as <code>struct</code>)
1304     */
1305    public static <T> Map<String, String> serializeStruct(T struct, Class<T> klass) {
1306        T structPrototype;
1307        try {
1308            structPrototype = klass.getConstructor().newInstance();
1309        } catch (ReflectiveOperationException ex) {
1310            throw new IllegalArgumentException(ex);
1311        }
1312
1313        Map<String, String> hash = new LinkedHashMap<>();
1314        for (Field f : klass.getDeclaredFields()) {
1315            if (f.getAnnotation(pref.class) == null) {
1316                continue;
1317            }
1318            Utils.setObjectsAccessible(f);
1319            try {
1320                Object fieldValue = f.get(struct);
1321                Object defaultFieldValue = f.get(structPrototype);
1322                if (fieldValue != null && (f.getAnnotation(writeExplicitly.class) != null || !Objects.equals(fieldValue, defaultFieldValue))) {
1323                    String key = f.getName().replace('_', '-');
1324                    if (fieldValue instanceof Map) {
1325                        hash.put(key, mapToJson((Map<?, ?>) fieldValue));
1326                    } else if (fieldValue instanceof MultiMap) {
1327                        hash.put(key, multiMapToJson((MultiMap<?, ?>) fieldValue));
1328                    } else {
1329                        hash.put(key, fieldValue.toString());
1330                    }
1331                }
1332            } catch (IllegalAccessException ex) {
1333                throw new JosmRuntimeException(ex);
1334            }
1335        }
1336        return hash;
1337    }
1338
1339    /**
1340     * Converts a String-Map to an object of a certain class, by comparing map keys to field names of the class and assigning
1341     * map values to the corresponding fields.
1342     *
1343     * The map value (a String) is converted to the field type. Supported types are: boolean, Boolean, int, Integer, double,
1344     * Double, String, Map&lt;String, String&gt; and Map&lt;String, List&lt;String&gt;&gt;.
1345     *
1346     * Only fields with annotation {@link pref} are taken into account.
1347     * @param <T> the class
1348     * @param hash the string map with initial values
1349     * @param klass the class T
1350     * @return an object of class T, initialized as described above
1351     */
1352    public static <T> T deserializeStruct(Map<String, String> hash, Class<T> klass) {
1353        T struct = null;
1354        try {
1355            struct = klass.getConstructor().newInstance();
1356        } catch (ReflectiveOperationException ex) {
1357            throw new IllegalArgumentException(ex);
1358        }
1359        for (Entry<String, String> key_value : hash.entrySet()) {
1360            Object value;
1361            Field f;
1362            try {
1363                f = klass.getDeclaredField(key_value.getKey().replace('-', '_'));
1364            } catch (NoSuchFieldException ex) {
1365                Main.trace(ex);
1366                continue;
1367            }
1368            if (f.getAnnotation(pref.class) == null) {
1369                continue;
1370            }
1371            Utils.setObjectsAccessible(f);
1372            if (f.getType() == Boolean.class || f.getType() == boolean.class) {
1373                value = Boolean.valueOf(key_value.getValue());
1374            } else if (f.getType() == Integer.class || f.getType() == int.class) {
1375                try {
1376                    value = Integer.valueOf(key_value.getValue());
1377                } catch (NumberFormatException nfe) {
1378                    continue;
1379                }
1380            } else if (f.getType() == Double.class || f.getType() == double.class) {
1381                try {
1382                    value = Double.valueOf(key_value.getValue());
1383                } catch (NumberFormatException nfe) {
1384                    continue;
1385                }
1386            } else if (f.getType() == String.class) {
1387                value = key_value.getValue();
1388            } else if (f.getType().isAssignableFrom(Map.class)) {
1389                value = mapFromJson(key_value.getValue());
1390            } else if (f.getType().isAssignableFrom(MultiMap.class)) {
1391                value = multiMapFromJson(key_value.getValue());
1392            } else
1393                throw new JosmRuntimeException("unsupported preference primitive type");
1394
1395            try {
1396                f.set(struct, value);
1397            } catch (IllegalArgumentException ex) {
1398                throw new AssertionError(ex);
1399            } catch (IllegalAccessException ex) {
1400                throw new JosmRuntimeException(ex);
1401            }
1402        }
1403        return struct;
1404    }
1405
1406    public Map<String, Setting<?>> getAllSettings() {
1407        return new TreeMap<>(settingsMap);
1408    }
1409
1410    public Map<String, Setting<?>> getAllDefaults() {
1411        return new TreeMap<>(defaultsMap);
1412    }
1413
1414    /**
1415     * Updates system properties with the current values in the preferences.
1416     *
1417     */
1418    public void updateSystemProperties() {
1419        if ("true".equals(get("prefer.ipv6", "auto")) && !"true".equals(Utils.updateSystemProperty("java.net.preferIPv6Addresses", "true"))) {
1420            // never set this to false, only true!
1421            Main.info(tr("Try enabling IPv6 network, prefering IPv6 over IPv4 (only works on early startup)."));
1422        }
1423        Utils.updateSystemProperty("http.agent", Version.getInstance().getAgentString());
1424        Utils.updateSystemProperty("user.language", get("language"));
1425        // Workaround to fix a Java bug. This ugly hack comes from Sun bug database: https://bugs.openjdk.java.net/browse/JDK-6292739
1426        // Force AWT toolkit to update its internal preferences (fix #6345).
1427        // Does not work anymore with Java 9, to remove with Java 9 migration
1428        if (!GraphicsEnvironment.isHeadless()) {
1429            try {
1430                Field field = Toolkit.class.getDeclaredField("resources");
1431                Utils.setObjectsAccessible(field);
1432                field.set(null, ResourceBundle.getBundle("sun.awt.resources.awt"));
1433            } catch (ReflectiveOperationException | RuntimeException e) {
1434                Main.warn(e);
1435            }
1436        }
1437        // Possibility to disable SNI (not by default) in case of misconfigured https servers
1438        // See #9875 + http://stackoverflow.com/a/14884941/2257172
1439        // then https://josm.openstreetmap.de/ticket/12152#comment:5 for details
1440        if (getBoolean("jdk.tls.disableSNIExtension", false)) {
1441            Utils.updateSystemProperty("jsse.enableSNIExtension", "false");
1442        }
1443    }
1444
1445    /**
1446     * Replies the collection of plugin site URLs from where plugin lists can be downloaded.
1447     * @return the collection of plugin site URLs
1448     * @see #getOnlinePluginSites
1449     */
1450    public Collection<String> getPluginSites() {
1451        return getCollection("pluginmanager.sites", Collections.singleton(Main.getJOSMWebsite()+"/pluginicons%<?plugins=>"));
1452    }
1453
1454    /**
1455     * Returns the list of plugin sites available according to offline mode settings.
1456     * @return the list of available plugin sites
1457     * @since 8471
1458     */
1459    public Collection<String> getOnlinePluginSites() {
1460        Collection<String> pluginSites = new ArrayList<>(getPluginSites());
1461        for (Iterator<String> it = pluginSites.iterator(); it.hasNext();) {
1462            try {
1463                OnlineResource.JOSM_WEBSITE.checkOfflineAccess(it.next(), Main.getJOSMWebsite());
1464            } catch (OfflineAccessException ex) {
1465                Main.warn(ex, false);
1466                it.remove();
1467            }
1468        }
1469        return pluginSites;
1470    }
1471
1472    /**
1473     * Sets the collection of plugin site URLs.
1474     *
1475     * @param sites the site URLs
1476     */
1477    public void setPluginSites(Collection<String> sites) {
1478        putCollection("pluginmanager.sites", sites);
1479    }
1480
1481    /**
1482     * Returns XML describing these preferences.
1483     * @param nopass if password must be excluded
1484     * @return XML
1485     */
1486    public String toXML(boolean nopass) {
1487        return toXML(settingsMap.entrySet(), nopass, false);
1488    }
1489
1490    /**
1491     * Returns XML describing the given preferences.
1492     * @param settings preferences settings
1493     * @param nopass if password must be excluded
1494     * @param defaults true, if default values are converted to XML, false for
1495     * regular preferences
1496     * @return XML
1497     */
1498    public String toXML(Collection<Entry<String, Setting<?>>> settings, boolean nopass, boolean defaults) {
1499        try (
1500            StringWriter sw = new StringWriter();
1501            PreferencesWriter prefWriter = new PreferencesWriter(new PrintWriter(sw), nopass, defaults)
1502        ) {
1503            prefWriter.write(settings);
1504            sw.flush();
1505            return sw.toString();
1506        } catch (IOException e) {
1507            Main.error(e);
1508            return null;
1509        }
1510    }
1511
1512    /**
1513     * Removes obsolete preference settings. If you throw out a once-used preference
1514     * setting, add it to the list here with an expiry date (written as comment). If you
1515     * see something with an expiry date in the past, remove it from the list.
1516     * @param loadedVersion JOSM version when the preferences file was written
1517     */
1518    private void removeObsolete(int loadedVersion) {
1519        // drop in March 2017
1520        removeUrlFromEntries(loadedVersion, 10063,
1521                "validator.org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.entries",
1522                "resource://data/validator/power.mapcss");
1523        // drop in March 2017
1524        if (loadedVersion < 11058) {
1525            migrateOldColorKeys();
1526        }
1527        // drop in September 2017
1528        if (loadedVersion < 11424) {
1529            addNewerDefaultEntry(
1530                    "validator.org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.entries",
1531                    "resource://data/validator/territories.mapcss");
1532        }
1533
1534        for (String key : OBSOLETE_PREF_KEYS) {
1535            if (settingsMap.containsKey(key)) {
1536                settingsMap.remove(key);
1537                Main.info(tr("Preference setting {0} has been removed since it is no longer used.", key));
1538            }
1539        }
1540    }
1541
1542    private void migrateOldColorKeys() {
1543        settingsMap.keySet().stream()
1544                .filter(key -> key.startsWith("color."))
1545                .flatMap(key -> {
1546                    final String newKey = ColorProperty.getColorKey(key.substring("color.".length()));
1547                    return key.equals(newKey) || settingsMap.containsKey(newKey)
1548                            ? Stream.empty()
1549                            : Stream.of(new AbstractMap.SimpleImmutableEntry<>(key, newKey));
1550                })
1551                .collect(Collectors.toList()) // to avoid ConcurrentModificationException
1552                .forEach(entry -> {
1553                    final String oldKey = entry.getKey();
1554                    final String newKey = entry.getValue();
1555                    Main.info("Migrating old color key {0} => {1}", oldKey, newKey);
1556                    put(newKey, get(oldKey));
1557                    put(oldKey, null);
1558                });
1559    }
1560
1561    private void removeUrlFromEntries(int loadedVersion, int versionMax, String key, String urlPart) {
1562        if (loadedVersion < versionMax) {
1563            Setting<?> setting = settingsMap.get(key);
1564            if (setting instanceof MapListSetting) {
1565                List<Map<String, String>> l = new LinkedList<>();
1566                boolean modified = false;
1567                for (Map<String, String> map: ((MapListSetting) setting).getValue()) {
1568                    String url = map.get("url");
1569                    if (url != null && url.contains(urlPart)) {
1570                        modified = true;
1571                    } else {
1572                        l.add(map);
1573                    }
1574                }
1575                if (modified) {
1576                    putListOfStructs(key, l);
1577                }
1578            }
1579        }
1580    }
1581
1582    private void addNewerDefaultEntry(String key, final String url) {
1583        Setting<?> setting = settingsMap.get(key);
1584        if (setting instanceof MapListSetting) {
1585            List<Map<String, String>> l = new ArrayList<>(((MapListSetting) setting).getValue());
1586            if (l.stream().noneMatch(x -> x.containsValue(url))) {
1587                RulePrefHelper helper = ValidatorTagCheckerRulesPreference.RulePrefHelper.INSTANCE;
1588                Optional<ExtendedSourceEntry> val = helper.getDefault().stream().filter(x -> url.equals(x.url)).findFirst();
1589                if (val.isPresent()) {
1590                    l.add(helper.serialize(val.get()));
1591                }
1592                putListOfStructs(key, l);
1593            }
1594        }
1595    }
1596
1597    /**
1598     * Enables or not the preferences file auto-save mechanism (save each time a setting is changed).
1599     * This behaviour is enabled by default.
1600     * @param enable if {@code true}, makes JOSM save preferences file each time a setting is changed
1601     * @since 7085
1602     */
1603    public final void enableSaveOnPut(boolean enable) {
1604        synchronized (this) {
1605            saveOnPut = enable;
1606        }
1607    }
1608}
Note: See TracBrowser for help on using the repository browser.