/home/leaf/crossfire/jxclient/trunk/gui/src/main/java/com/realtime/crossfire/jxclient/settings/Settings.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient 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.
 *
 * JXClient 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 JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff.
 * Copyright (C) 2006-2011 Andreas Kirschbaum.
 */

package com.realtime.crossfire.jxclient.settings;

import com.realtime.crossfire.jxclient.util.NumberParser;
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.TreeMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class Settings {

    @NotNull
    private final File file;

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

    private boolean noSave = true;

    public Settings(@NotNull final File file) {
        this.file = file;
        loadValues();
        noSave = false;
    }

    @NotNull
    public String getString(@NotNull final String key, @NotNull final String defaultValue) {
        final Entry entry = values.get(key);
        return entry != null ? entry.getValue() : defaultValue;
    }

    public boolean getBoolean(@NotNull final String key, final boolean defaultValue) {
        final String value = getString(key, Boolean.toString(defaultValue));
        try {
            return Boolean.parseBoolean(value);
        } catch (final NumberFormatException ignored) {
            return defaultValue;
        }
    }

    public int getInt(@NotNull final String key, final int defaultValue) {
        return NumberParser.parseInt(getString(key, Integer.toString(defaultValue)), defaultValue);
    }

    public long getLong(@NotNull final String key, final long defaultValue) {
        return NumberParser.parseLong(getString(key, Long.toString(defaultValue)), defaultValue);
    }

    public void putString(@NotNull final String key, @NotNull final String value, @Nullable final String documentation) {
        final Entry oldEntry = values.get(key);
        if (oldEntry != null) {
            oldEntry.setDocumentation(documentation);
            if (!oldEntry.getValue().equals(value)) {
                oldEntry.setValue(value);
                setChanged();
            }
        } else {
            values.put(key, new Entry(value, documentation));
        }
    }

    public void putBoolean(@NotNull final String key, final boolean value, @NotNull final String documentation) {
        putString(key, Boolean.toString(value), documentation);
    }

    public void putInt(@NotNull final String key, final int value, @NotNull final String documentation) {
        putString(key, Integer.toString(value), documentation);
    }

    public void putLong(@NotNull final String key, final long value, @NotNull final String documentation) {
        putString(key, Long.toString(value), documentation);
    }

    public void remove(@NotNull final String key) {
        if (values.remove(key) != null) {
            setChanged();
        }
    }

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

        try {
            saveValues();
        } catch (final IOException ex) {
            System.err.println(file+": "+ex.getMessage());
        }
    }

    private void loadValues() {
        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 {
                        while (true) {
                            final String line2 = lnr.readLine();
                            if (line2 == null) {
                                break;
                            }
                            final String line = Codec.decode(line2.trim());
                            if (line == null || line.startsWith("#") || line.length() == 0) {
                                continue;
                            }

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

                            putString(key, value, null);
                        }
                    } finally {
                        lnr.close();
                    }
                } finally {
                    isr.close();
                }
            } finally {
                fis.close();
            }
        } catch (final FileNotFoundException ignored) {
            // ignore
        } catch (final IOException ex) {
            System.err.println(file+": "+ex.getMessage());
        }
    }

    private void saveValues() throws IOException {
        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 {
                    saveNode(bw, values);
                } finally {
                    bw.close();
                }
            } finally {
                osw.close();
            }
        } finally {
            fos.close();
        }

        if (!tmpFile.renameTo(file)) {
            throw new IOException("cannot rename "+tmpFile+" to "+file);
        }
    }

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

        for (final Map.Entry<String, Entry> entry : node.entrySet()) {
            final Entry value = entry.getValue();

            writer.newLine();

            final String documentation = value.getDocumentation();
            if (documentation != null) {
                writer.write("# ");
                writer.write(Codec.encode(documentation));
                writer.newLine();
            }

            writer.write(Codec.encode(entry.getKey()));
            writer.write("=");
            writer.write(Codec.encode(value.getValue()));
            writer.newLine();
        }
    }

}

---