Java tutorial
/* * Copyright 2015 Igor Maznitsa. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.igormaznitsa.ideamindmap.facet; import com.intellij.util.Base64; import org.apache.commons.lang.StringEscapeUtils; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.io.IOException; import java.io.OutputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.prefs.BackingStoreException; import java.util.prefs.NodeChangeListener; import java.util.prefs.PreferenceChangeEvent; import java.util.prefs.PreferenceChangeListener; import java.util.prefs.Preferences; public class InMemoryPreferenceNode extends Preferences { private final List<PreferenceChangeListener> preferenceChangeListeners = new ArrayList<PreferenceChangeListener>(); private final List<NodeChangeListener> nodeChangeListeners = new ArrayList<NodeChangeListener>(); private final Map<String, String> storage = new HashMap<String, String>(); private void firePreferenceListeners(final String key, final String newValue) { final PreferenceChangeEvent event = new PreferenceChangeEvent(this, key, newValue); for (final PreferenceChangeListener l : this.preferenceChangeListeners) { l.preferenceChange(event); } } @Override public void put(@Nonnull final String key, @Nonnull final String value) { this.storage.put(key, value); firePreferenceListeners(key, value); } @Override public String get(@Nonnull final String key, @Nullable String def) { return this.storage.get(key); } @Override public void remove(@Nonnull final String key) { if (this.storage.remove(key) != null) { firePreferenceListeners(key, null); } } @Override public void clear() throws BackingStoreException { final Map<String, String> copy = new HashMap<String, String>(this.storage); this.storage.clear(); for (final String k : copy.keySet()) { firePreferenceListeners(k, null); } } @Override public void putInt(@Nonnull final String key, final int value) { this.put(key, Integer.toString(value)); } @Override public int getInt(@Nonnull String key, final int def) { final String value = this.get(key, Integer.toString(def)); try { return Integer.parseInt(value); } catch (NumberFormatException ex) { return def; } } @Override public void putLong(@Nonnull final String key, final long value) { this.put(key, Long.toString(value)); } @Override public long getLong(String key, long def) { final String value = this.get(key, Long.toString(def)); try { return Long.parseLong(value); } catch (NumberFormatException ex) { return def; } } @Override public void putBoolean(String key, boolean value) { this.put(key, Boolean.toString(value)); } @Override public boolean getBoolean(String key, boolean def) { final String value = this.get(key, null); return value == null ? def : Boolean.parseBoolean(value); } @Override public void putFloat(String key, float value) { this.put(key, Float.toString(value)); } @Override public float getFloat(String key, float def) { final String value = get(key, Float.toString(def)); try { return Float.parseFloat(value); } catch (NumberFormatException ex) { return def; } } @Override public void putDouble(String key, double value) { this.put(key, Double.toString(value)); } @Override public double getDouble(String key, double def) { final String value = get(key, Double.toString(def)); try { return Double.parseDouble(value); } catch (NumberFormatException ex) { return def; } } @Override public void putByteArray(String key, byte[] value) { this.put(key, Base64.encode(value)); } @Override public byte[] getByteArray(String key, byte[] def) { final String value = this.get(key, null); try { return Base64.decode(value); } catch (Exception ex) { return def; } } @Override public String[] keys() throws BackingStoreException { return this.storage.keySet().toArray(new String[this.storage.size()]); } @Override public String[] childrenNames() throws BackingStoreException { return new String[0]; } @Override public Preferences parent() { return null; } @Override public Preferences node(final String pathName) { return null; } @Override public boolean nodeExists(final String pathName) throws BackingStoreException { return false; } @Override public void removeNode() throws BackingStoreException { } @Override public String name() { return ".."; } @Override public String absolutePath() { return ".."; } @Override public boolean isUserNode() { return false; } @Override public String toString() { return InMemoryPreferenceNode.class.getName() + "[" + this.storage.size() + ']'; } @Override public void flush() throws BackingStoreException { } @Override public void sync() throws BackingStoreException { } @Override public void addPreferenceChangeListener(PreferenceChangeListener pcl) { this.preferenceChangeListeners.add(pcl); } @Override public void removePreferenceChangeListener(PreferenceChangeListener pcl) { this.preferenceChangeListeners.remove(pcl); } @Override public void addNodeChangeListener(NodeChangeListener ncl) { this.nodeChangeListeners.add(ncl); } @Override public void removeNodeChangeListener(NodeChangeListener ncl) { this.nodeChangeListeners.remove(ncl); } @Override public void exportNode(OutputStream os) throws IOException, BackingStoreException { final StringBuilder builder = new StringBuilder(); for (final Map.Entry<String, String> entry : this.storage.entrySet()) { builder.append(StringEscapeUtils.escapeCsv(entry.getKey())).append(',') .append(StringEscapeUtils.escapeCsv(entry.getValue())).append('\n'); } os.write(builder.toString().getBytes("UTF-8")); } @Override public void exportSubtree(OutputStream os) throws IOException, BackingStoreException { } }