PreferencesMap.java

/*
 PreferencesMap - A Map<String, String> with some useful features 
 to handle preferences.
 Part of the Arduino project - http://www.arduino.cc/

 Copyright (c) 2014 Cristian Maglie

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software Foundation,
 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
packageprocessing.app.helpers;

importorg.apache.commons.compress.utils.IOUtils;
importprocessing.app.legacy.PApplet;

importjava.io.*;
importjava.util.LinkedHashMap;
importjava.util.Map;
importjava.util.SortedSet;
importjava.util.TreeSet;

@SuppressWarnings("serial")
publicclassPreferencesMapextendsLinkedHashMap<String, String> {

publicPreferencesMap(Map<String, String> table) {
super(table);
 }

/**
 * Create a PreferencesMap and load the content of the file passed as
 * argument.
 * 
 * Is equivalent to:
 * 
 * <pre>
 * PreferencesMap map = new PreferencesMap();
 * map.load(file);
 * </pre>
 * 
 * @param file
 * @throws IOException
 */
publicPreferencesMap(Filefile) throwsIOException {
super();
load(file);
 }

publicPreferencesMap() {
super();
 }

/**
 * Parse a property list file and put kev/value pairs into the Map
 * 
 * @param file
 * @throws FileNotFoundException
 * @throws IOException
 */
publicvoidload(Filefile) throwsIOException {
FileInputStreamfileInputStream = null;
try {
fileInputStream = newFileInputStream(file);
load(fileInputStream);
 } finally {
IOUtils.closeQuietly(fileInputStream);
 }
 }

protectedStringprocessPlatformSuffix(Stringkey, Stringsuffix, booleanisCurrentPlatform) {
if (key == null)
returnnull;
// Key does not end with the given suffix? Process as normal
if (!key.endsWith(suffix))
returnkey;
// Not the current platform? Ignore this key
if (!isCurrentPlatform)
returnnull;
// Strip the suffix from the key
returnkey.substring(0, key.length() - suffix.length());
 }

/**
 * Parse a property list stream and put key/value pairs into the Map
 * 
 * @param input
 * @throws IOException
 */
publicvoidload(InputStreaminput) throwsIOException {
String[] lines = PApplet.loadStrings(input);
for (Stringline : lines) {
if (line.length() == 0 || line.charAt(0) == '#')
continue;

intequals = line.indexOf('=');
if (equals != -1) {
Stringkey = line.substring(0, equals).trim();
Stringvalue = line.substring(equals + 1).trim();

key = processPlatformSuffix(key, ".linux", OSUtils.isLinux());
key = processPlatformSuffix(key, ".windows", OSUtils.isWindows());
key = processPlatformSuffix(key, ".macosx", OSUtils.isMacOS());

if (key != null)
put(key, value);
 }
 }
 }

/**
 * Create a new PreferenceMap that contains all the top level pairs of the
 * current mapping. E.g. the folowing mapping:<br />
 * 
 * <pre>
 * Map (
 * alpha = Alpha
 * alpha.some.keys = v1
 * alpha.other.keys = v2
 * beta = Beta
 * beta.some.keys = v3
 * )
 * </pre>
 * 
 * will generate the following result:
 * 
 * <pre>
 * Map (
 * alpha = Alpha
 * beta = Beta
 * )
 * </pre>
 * 
 * @return
 */
publicPreferencesMaptopLevelMap() {
PreferencesMapres = newPreferencesMap();
for (Stringkey : keySet()) {
if (key.contains("."))
continue;
res.put(key, get(key));
 }
returnres;
 }

/**
 * Create a new Map<String, PreferenceMap> where keys are the first level of
 * the current mapping. Top level pairs are discarded. E.g. the folowing
 * mapping:<br />
 * 
 * <pre>
 * Map (
 * alpha = Alpha
 * alpha.some.keys = v1
 * alpha.other.keys = v2
 * beta = Beta
 * beta.some.keys = v3
 * )
 * </pre>
 * 
 * will generate the following result:
 * 
 * <pre>
 * alpha = Map(
 * some.keys = v1
 * other.keys = v2
 * )
 * beta = Map(
 * some.keys = v3
 * )
 * </pre>
 * 
 * @return
 */
publicMap<String, PreferencesMap> firstLevelMap() {
Map<String, PreferencesMap> res = newLinkedHashMap<>();
for (Stringkey : keySet()) {
intdot = key.indexOf('.');
if (dot == -1)
continue;

Stringparent = key.substring(0, dot);
Stringchild = key.substring(dot + 1);

if (!res.containsKey(parent))
res.put(parent, newPreferencesMap());
res.get(parent).put(child, get(key));
 }
returnres;
 }

/**
 * Create a new PreferenceMap using a subtree of the current mapping. Top
 * level pairs are ignored. E.g. with the following mapping:<br />
 * 
 * <pre>
 * Map (
 * alpha = Alpha
 * alpha.some.keys = v1
 * alpha.other.keys = v2
 * beta = Beta
 * beta.some.keys = v3
 * )
 * </pre>
 * 
 * a call to createSubTree("alpha") will generate the following result:
 * 
 * <pre>
 * Map(
 * some.keys = v1
 * other.keys = v2
 * )
 * </pre>
 * 
 * @param parent
 * @return
 */
publicPreferencesMapsubTree(Stringparent) {
returnsubTree(parent, -1);
 }

publicPreferencesMapsubTree(Stringparent, intsublevels) {
PreferencesMapres = newPreferencesMap();
parent += ".";
intparentLen = parent.length();
for (Stringkey : keySet()) {
if (key.startsWith(parent)) {
StringnewKey = key.substring(parentLen);
intkeySubLevels = newKey.split("\\.").length;
if (sublevels == -1 || keySubLevels == sublevels) {
res.put(newKey, get(key));
 }
 }
 }
returnres;
 }

publicStringtoString(Stringindent) {
Stringres = indent + "{\n";
SortedSet<String> treeSet = newTreeSet<>(keySet());
for (Stringk : treeSet)
res += indent + " " + k + " = " + get(k) + "\n";
res += indent + "}\n";
returnres;
 }

/**
 * Returns the value to which the specified key is mapped, or throws a
 * PreferencesMapException if not found
 * 
 * @param k
 * the key whose associated value is to be returned
 * @return the value to which the specified key is mapped
 * @throws PreferencesMapException
 */
publicStringgetOrExcept(Stringk) throwsPreferencesMapException {
Stringr = get(k);
if (r == null)
thrownewPreferencesMapException(k);
returnr;
 }

@Override
publicStringtoString() {
returntoString("");
 }

/**
 * Creates a new File instance by converting the value of the key into an
 * abstract pathname. If the the given key doesn't exists or his value is the
 * empty string, the result is <b>null</b>.
 * 
 * @param key
 * @return
 */
publicFilegetFile(Stringkey) {
if (!containsKey(key))
returnnull;
Stringpath = get(key).trim();
if (path.length() == 0)
returnnull;
returnnewFile(path);
 }

/**
 * Creates a new File instance by converting the value of the key into an
 * abstract pathname with the specified sub folder. If the the given key
 * doesn't exists or his value is the empty string, the result is <b>null</b>.
 * 
 * @param key
 * @param subFolder
 * @return
 */
publicFilegetFile(Stringkey, StringsubFolder) {
Filefile = getFile(key);
if (file == null)
returnnull;
returnnewFile(file, subFolder);
 }

/**
 * Return the value of the specified key as boolean.
 * 
 * @param key
 * @return <b>true</b> if the value of the key is the string "true" (case
 * insensitive compared), <b>false</b> in any other case
 */
publicbooleangetBoolean(Stringkey) {
returnBoolean.valueOf(get(key));
 }

/**
 * Sets the value of the specified key to the string <b>"true"</b> or
 * <b>"false"</b> based on value of the boolean parameter
 * 
 * @param key
 * @param value
 * @return <b>true</b> if the previous value of the key was the string "true"
 * (case insensitive compared), <b>false</b> in any other case
 */
publicbooleanputBoolean(Stringkey, booleanvalue) {
Stringprev = put(key, value ? "true" : "false");
returnnewBoolean(prev);
 }

publicStringget(Stringkey, StringdefaultValue) {
Stringvalue = get(key);
if (value != null) {
returnvalue;
 }
returndefaultValue;
 }

}