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-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.settings;
 
import com.realtime.crossfire.jxclient.util.Codec;
import com.realtime.crossfire.jxclient.util.NumberParser;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.LineNumberReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.Map;
import java.util.TreeMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class Settings {
 
    @NotNull
    private final Path file;
 
    @NotNull
    private final Map<String, Entry> values = new TreeMap<>();
 
    private boolean noSave = true;
 
    public Settings(@NotNull final Path file) {
        this.file = file;
        loadValues();
        noSave = false;
    }
 
    @NotNull
    public String getString(@NotNull final SettingsEntry<?> key) {
        Entry entry = values.get(key.getKey());
        if (entry == null && (key.getKey().equals("sound_music_enabled") || key.getKey().equals("sound_effects_enabled"))) { // hack to support old settings key as well
            entry = values.get("sound_enabled");
        }
        return entry == null ? key.getDefaultValue().toString() : entry.getValue();
    }
 
    public boolean getBoolean(@NotNull final SettingsEntry<Boolean> key) {
        final String value = getString(key);
        try {
            return Boolean.parseBoolean(value);
        } catch (final NumberFormatException ignored) {
            return key.getDefaultValue();
        }
    }
 
    public int getInt(@NotNull final SettingsEntry<Integer> key) {
        return NumberParser.parseInt(getString(key), key.getDefaultValue());
    }
 
    public long getLong(@NotNull final SettingsEntry<Long> key) {
        return NumberParser.parseLong(getString(key), key.getDefaultValue());
    }
 
    public void putString(@NotNull final SettingsEntry<?> key, @NotNull final String value) {
        final Entry oldEntry = values.get(key.getKey());
        if (oldEntry == null) {
            values.put(key.getKey(), new Entry(value, key.getComment()));
            setChanged();
        } else {
            final boolean documentationChanged = oldEntry.setDocumentation(key.getComment());
            final boolean valueChanged = !oldEntry.getValue().equals(value);
            if (valueChanged) {
                oldEntry.setValue(value);
            }
            if (documentationChanged || valueChanged) {
                setChanged();
            }
        }
    }
 
    public void putBoolean(@NotNull final SettingsEntry<Boolean> key, final boolean value) {
        putString(key, Boolean.toString(value));
    }
 
    public void putInt(@NotNull final SettingsEntry<Integer> key, final int value) {
        putString(key, Integer.toString(value));
    }
 
    public void putLong(@NotNull final SettingsEntry<Long> key, final long value) {
        putString(key, Long.toString(value));
    }
 
    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 {
            try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
                try (LineNumberReader lnr = new LineNumberReader(reader)) {
                    loadValues(lnr);
                }
            }
        } catch (final NoSuchFileException ignored) {
            // ignore
        } catch (final IOException ex) {
            System.err.println(file+": "+ex.getMessage());
        }
    }
 
    private void loadValues(@NotNull final LineNumberReader lnr) throws IOException {
        @Nullable String comment = null;
        while (true) {
            final String line2 = lnr.readLine();
            if (line2 == null) {
                break;
            }
            final String line = Codec.decode(line2.trim());
            if (line.isEmpty()) {
                comment = null;
                continue;
            }
            if (line.startsWith("#")) {
                comment = line.substring(1).trim();
                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(new SettingsEntry<>(key, "", comment), value);
            comment = null;
        }
    }
 
    private void saveValues() throws IOException {
        final Path tmpFile = file.resolveSibling(file.getFileName()+".tmp");
        try (BufferedWriter bw = Files.newBufferedWriter(tmpFile, StandardCharsets.UTF_8)) {
            saveNode(bw, values);
        }
 
        Files.move(tmpFile, file, StandardCopyOption.REPLACE_EXISTING);
    }
 
    private static void saveNode(@NotNull final BufferedWriter writer, @NotNull final Map<String, Entry> node) throws IOException {
        if (node.isEmpty()) {
            return;
        }
 
        for (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();
        }
    }
 
}