Storage.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.preferences;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStreamWriter;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.prefs.BackingStoreException;
import java.util.regex.Pattern;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class Storage {

    @NotNull
    private static final Pattern PATTERN_EQUAL = Pattern.compile("=");

    @NotNull
    private static final Category LOG = Logger.getLogger(Storage.class);

    @NotNull
    private final String defaultPath;

    @Nullable
    private final File file;

    private boolean noSave = true;

    @NotNull
    private static final Pattern PATTERN_IGNORE = Pattern.compile("[\\[].*");

    @NotNull
    private final Map<String, Map<String, String>> values = new TreeMap<>();

    public Storage(@NotNull final String defaultPath, @Nullable final File file) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("new");
        }

        this.defaultPath = defaultPath;
        this.file = file;

        loadValues();
        noSave = false;
    }

    public void newNode(@NotNull final String path) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("newNode(" + path + ")");
        }

        if (!values.containsKey(path)) {
            values.put(path, new TreeMap<>());
        }
    }

    @NotNull
    public String[] childrenNames(@NotNull final String path) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("childrenNames(" + path + ")");
        }

        final String prefix = path + "/";
        final Set<String> result = new TreeSet<>();
        for (final String key : values.keySet()) {
            if (key.startsWith(prefix)) {
                result.add(key.substring(prefix.length()));
            }
        }
        return result.toArray(new String[result.size()]);
    }

    @Nullable
    public String getValue(@NotNull final String path, @NotNull final String key) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("getValue(" + path + ", " + key + ")");
        }

        final Map<String, String> map = values.get(path);
        assert map != null; // AbstractPreferences.getSpi() ensures this
        return map.get(key);
    }

    @NotNull
    public String[] getKeys(@NotNull final String path) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("getKeys(" + path + ")");
        }

        final Map<String, String> map = values.get(path);
        assert map != null; // AbstractPreferences.keysSpi() ensures this
        final Set<String> keys = map.keySet();
        return keys.toArray(new String[keys.size()]);
    }

    public void putValue(@NotNull final String path, @NotNull final String key, @NotNull final String value) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("putValue(" + path + ", " + key + ", " + value + ")");
        }

        final Map<String, String> map = values.get(path);
        assert map != null; // AbstractPreferences.putSpi() ensures this
        final String oldValue = map.put(key, value);
        if (oldValue == null || !oldValue.equals(value)) {
            setChanged();
        }
    }

    public void removeNode(@NotNull final String path) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("removeNode(" + path + ")");
        }

        if (values.remove(path) != null) {
            setChanged();
        }
    }

    public void removeValue(@NotNull final String path, @NotNull final String key) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("removeValue(" + path + ", " + key + ")");
        }

        final Map<String, String> map = values.get(path);
        assert map != null; // AbstractPreferences.removeSpi() ensures this
        if (map.remove(key) != null) {
            setChanged();
        }
    }

    public void sync(final boolean sync) throws BackingStoreException {
        if (LOG.isDebugEnabled()) {
            LOG.debug("sync(" + sync + ")");
        }

        try {
            saveValues();
        } catch (final IOException ex) {
            throw new BackingStoreException(ex);
        }
    }

    private void setChanged() {
        if (noSave) {
            return;
        }

        try {
            saveValues();
        } catch (final IOException ex) {
            LOG.warn(file + ": " + ex.getMessage());
        }
    }

    private void loadValues() {
        if (file == null) {
            return;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("loadValues: " + file);
        }

        values.clear();

        try {
            final FileInputStream fis = new FileInputStream(file);
            try {
                final InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
                try {
                    final LineNumberReader lnr = new LineNumberReader(isr);
                    try {
                        loadValues(lnr);
                    } finally {
                        lnr.close();
                    }
                } finally {
                    isr.close();
                }
            } finally {
                fis.close();
            }
        } catch (final FileNotFoundException ignored) {
            // ignore
        } catch (final IOException ex) {
            LOG.warn(file + ": " + ex.getMessage());
        }
    }

    private void loadValues(@NotNull final LineNumberReader lnr) throws IOException {
        String path = defaultPath;
        while (true) {
            final String line2 = lnr.readLine();
            if (line2 == null) {
                break;
            }
            final String line = Codec.decode(line2.trim());
            if (line.startsWith("#") || line.isEmpty()) {
                continue;
            }

            if (line.startsWith("[") && line.endsWith("]")) {
                path = line.substring(1, line.length() - 1);
                continue;
            }

            final String[] tmp = PATTERN_EQUAL.split(line, 2);
            if (tmp.length != 2) {
                LOG.warn(file + ":" + lnr.getLineNumber() + ": syntax error");
                continue;
            }
            final String key = tmp[0];
            final String value = tmp[1];

            newNode(path);
            putValue(path, key, value);
        }
    }

    private void saveValues() throws IOException {
        if (file == null) {
            return;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("saveValues: " + file);
        }

        final File tmpFile = new File(file.getPath() + ".tmp");
        final FileOutputStream fos = new FileOutputStream(tmpFile);
        try {
            final OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
            try {
                final BufferedWriter bw = new BufferedWriter(osw);
                try {
                    final Map<String, String> defaultNode = values.get(defaultPath);
                    if (defaultNode != null) {
                        saveNode(bw, null, defaultNode);
                    }

                    for (final Map.Entry<String, Map<String, String>> e : values.entrySet()) {
                        if (!e.getKey().equals(defaultPath)) {
                            saveNode(bw, e.getKey(), e.getValue());
                        }
                    }
                } finally {
                    bw.close();
                }
            } finally {
                osw.close();
            }
        } finally {
            fos.close();
        }

        //noinspection ResultOfMethodCallIgnored
        file.delete(); // Windows cannot overwrite destination file on rename
        if (!tmpFile.renameTo(file)) {
            throw new IOException("cannot rename " + tmpFile + " to " + file);
        }
    }

    private static void saveNode(@NotNull final BufferedWriter writer, @Nullable final String path, @NotNull final Map<String, String> node) throws IOException {
        if (node.isEmpty()) {
            return;
        }

        final ActionBuilder actionBuilder = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");

        if (path != null) {
            writer.newLine();
            writer.write("[");
            writer.write(Codec.encode(path));
            writer.write("]");
            writer.newLine();
        }

        for (final Map.Entry<String, String> entry : node.entrySet()) {
            writer.newLine();

            final String comment = actionBuilder.getString("prefs." + PATTERN_IGNORE.matcher(entry.getKey()).replaceAll(""));
            if (comment != null) {
                writer.write("# ");
                writer.write(comment);
                writer.newLine();
            }
            writer.write(Codec.encode(entry.getKey()));
            writer.write("=");
            writer.write(Codec.encode(entry.getValue()));
            writer.newLine();
        }
    }

}