Java tutorial
/** * ProtocolLib - Bukkit server library that allows access to the Minecraft protocol. * Copyright (C) 2012 Kristian S. Stangeland * * 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 */ package com.comphenix.protocol; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Locale; import org.bukkit.configuration.Configuration; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.plugin.Plugin; import com.comphenix.protocol.injector.PlayerInjectHooks; import com.google.common.base.Charsets; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; import com.google.common.io.Files; /** * Represents the configuration of ProtocolLib. * * @author Kristian */ public class ProtocolConfig { private static final String LAST_UPDATE_FILE = "lastupdate"; private static final String SECTION_GLOBAL = "global"; private static final String SECTION_AUTOUPDATER = "auto updater"; private static final String METRICS_ENABLED = "metrics"; private static final String IGNORE_VERSION_CHECK = "ignore version check"; private static final String BACKGROUND_COMPILER_ENABLED = "background compiler"; private static final String DEBUG_MODE_ENABLED = "debug"; private static final String DETAILED_ERROR = "detailed error"; private static final String INJECTION_METHOD = "injection method"; private static final String SCRIPT_ENGINE_NAME = "script engine"; private static final String SUPPRESSED_REPORTS = "suppressed reports"; private static final String UPDATER_NOTIFY = "notify"; private static final String UPDATER_DOWNLAD = "download"; private static final String UPDATER_DELAY = "delay"; // Defaults private static final long DEFAULT_UPDATER_DELAY = 43200; private Plugin plugin; private Configuration config; private boolean loadingSections; private ConfigurationSection global; private ConfigurationSection updater; // Last update time private long lastUpdateTime; private boolean configChanged; private boolean valuesChanged; // Modifications private int modCount; public ProtocolConfig(Plugin plugin) { this.plugin = plugin; reloadConfig(); } /** * Reload configuration file. */ public void reloadConfig() { // Reset configChanged = false; valuesChanged = false; modCount++; this.config = plugin.getConfig(); this.lastUpdateTime = loadLastUpdate(); loadSections(!loadingSections); } /** * Load the last update time stamp from the file system. * * @return Last update time stamp. */ private long loadLastUpdate() { File dataFile = getLastUpdateFile(); if (dataFile.exists()) { try { return Long.parseLong(Files.toString(dataFile, Charsets.UTF_8)); } catch (NumberFormatException e) { plugin.getLogger().warning("Cannot parse " + dataFile + " as a number."); } catch (IOException e) { plugin.getLogger().warning("Cannot read " + dataFile); } } // Default last update return 0; } /** * Store the given time stamp. * * @param value - time stamp to store. */ private void saveLastUpdate(long value) { File dataFile = getLastUpdateFile(); // The data folder must exist dataFile.getParentFile().mkdirs(); if (dataFile.exists()) dataFile.delete(); try { Files.write(Long.toString(value), dataFile, Charsets.UTF_8); } catch (IOException e) { throw new RuntimeException("Cannot write " + dataFile, e); } } /** * Retrieve the file that is used to store the update time stamp. * * @return File storing the update time stamp. */ private File getLastUpdateFile() { return new File(plugin.getDataFolder(), LAST_UPDATE_FILE); } /** * Load data sections. * * @param copyDefaults - whether or not to copy configuration defaults. */ private void loadSections(boolean copyDefaults) { if (config != null) { global = config.getConfigurationSection(SECTION_GLOBAL); } if (global != null) { updater = global.getConfigurationSection(SECTION_AUTOUPDATER); if (updater.getValues(true).isEmpty()) { plugin.getLogger().warning("Updater section is missing, regenerate your config!"); } } // Automatically copy defaults if (copyDefaults && (!getFile().exists() || global == null || updater == null)) { loadingSections = true; if (config != null) config.options().copyDefaults(true); plugin.saveDefaultConfig(); plugin.reloadConfig(); loadingSections = false; // Inform the user plugin.getLogger().info("Created default configuration."); } } /** * Set a particular configuration key value pair. * * @param section - the configuration root. * @param path - the path to the key. * @param value - the value to set. */ private void setConfig(ConfigurationSection section, String path, Object value) { configChanged = true; section.set(path, value); } @SuppressWarnings("unchecked") private <T> T getGlobalValue(String path, T def) { try { return (T) global.get(path, def); } catch (Throwable ex) { return def; } } @SuppressWarnings("unchecked") private <T> T getUpdaterValue(String path, T def) { try { return (T) updater.get(path, def); } catch (Throwable ex) { return def; } } /** * Retrieve a reference to the configuration file. * * @return Configuration file on disk. */ public File getFile() { return new File(plugin.getDataFolder(), "config.yml"); } /** * Determine if detailed error reporting is enabled. Default FALSE. * * @return TRUE if it is enabled, FALSE otherwise. */ public boolean isDetailedErrorReporting() { return getGlobalValue(DETAILED_ERROR, false); } /** * Set whether or not detailed error reporting is enabled. * * @param value - TRUE if it is enabled, FALSE otherwise. */ public void setDetailedErrorReporting(boolean value) { global.set(DETAILED_ERROR, value); } /** * Retrieve whether or not ProtocolLib should determine if a new version has been released. * * @return TRUE if it should do this automatically, FALSE otherwise. */ public boolean isAutoNotify() { return getUpdaterValue(UPDATER_NOTIFY, true); } /** * Set whether or not ProtocolLib should determine if a new version has been released. * * @param value - TRUE to do this automatically, FALSE otherwise. */ public void setAutoNotify(boolean value) { setConfig(updater, UPDATER_NOTIFY, value); modCount++; } /** * Retrieve whether or not ProtocolLib should automatically download the new version. * * @return TRUE if it should, FALSE otherwise. */ public boolean isAutoDownload() { return updater != null && getUpdaterValue(UPDATER_DOWNLAD, false); } /** * Set whether or not ProtocolLib should automatically download the new version. * * @param value - TRUE if it should. FALSE otherwise. */ public void setAutoDownload(boolean value) { setConfig(updater, UPDATER_DOWNLAD, value); modCount++; } /** * Determine whether or not debug mode is enabled. * <p> * This grants access to the filter command. * * @return TRUE if it is, FALSE otherwise. */ public boolean isDebug() { return getGlobalValue(DEBUG_MODE_ENABLED, false); } /** * Set whether or not debug mode is enabled. * * @param value - TRUE if it is enabled, FALSE otherwise. */ public void setDebug(boolean value) { setConfig(global, DEBUG_MODE_ENABLED, value); modCount++; } /** * Retrieve an immutable list of every suppressed report type. * * @return Every suppressed report type. */ public ImmutableList<String> getSuppressedReports() { return ImmutableList.copyOf(getGlobalValue(SUPPRESSED_REPORTS, new ArrayList<String>())); } /** * Set the list of suppressed report types, * * @param reports - suppressed report types. */ public void setSuppressedReports(List<String> reports) { global.set(SUPPRESSED_REPORTS, Lists.newArrayList(reports)); modCount++; } /** * Retrieve the amount of time to wait until checking for a new update. * * @return The amount of time to wait. */ public long getAutoDelay() { // Note that the delay must be greater than 59 seconds return Math.max(getUpdaterValue(UPDATER_DELAY, 0), DEFAULT_UPDATER_DELAY); } /** * Set the amount of time to wait until checking for a new update. * <p> * This time must be greater than 59 seconds. * * @param delaySeconds - the amount of time to wait. */ public void setAutoDelay(long delaySeconds) { // Silently fix the delay if (delaySeconds < DEFAULT_UPDATER_DELAY) delaySeconds = DEFAULT_UPDATER_DELAY; setConfig(updater, UPDATER_DELAY, delaySeconds); modCount++; } /** * The version of Minecraft to ignore the built-in safety feature. * * @return The version to ignore ProtocolLib's satefy. */ public String getIgnoreVersionCheck() { return getGlobalValue(IGNORE_VERSION_CHECK, ""); } /** * Sets under which version of Minecraft the version safety feature will be ignored. * <p> * This is useful if a server operator has tested and verified that a version of ProtocolLib works, but doesn't want or can't upgrade to a newer version. * * @param ignoreVersion - the version of Minecraft where the satefy will be disabled. */ public void setIgnoreVersionCheck(String ignoreVersion) { setConfig(global, IGNORE_VERSION_CHECK, ignoreVersion); modCount++; } /** * Retrieve whether or not metrics is enabled. * * @return TRUE if metrics is enabled, FALSE otherwise. */ public boolean isMetricsEnabled() { return getGlobalValue(METRICS_ENABLED, true); } /** * Set whether or not metrics is enabled. * <p> * This setting will take effect next time ProtocolLib is started. * * @param enabled - whether or not metrics is enabled. */ public void setMetricsEnabled(boolean enabled) { setConfig(global, METRICS_ENABLED, enabled); modCount++; } /** * Retrieve whether or not the background compiler for structure modifiers is enabled or not. * * @return TRUE if it is enabled, FALSE otherwise. */ public boolean isBackgroundCompilerEnabled() { return getGlobalValue(BACKGROUND_COMPILER_ENABLED, true); } /** * Set whether or not the background compiler for structure modifiers is enabled or not. * <p> * This setting will take effect next time ProtocolLib is started. * * @param enabled - TRUE if is enabled/running, FALSE otherwise. */ public void setBackgroundCompilerEnabled(boolean enabled) { setConfig(global, BACKGROUND_COMPILER_ENABLED, enabled); modCount++; } /** * Retrieve the last time we updated, in seconds since 1970.01.01 00:00. * * @return Last update time. */ public long getAutoLastTime() { return lastUpdateTime; } /** * Set the last time we updated, in seconds since 1970.01.01 00:00. * <p> * Note that this is not considered to modify the configuration, so the modification count will not be incremented. * * @param lastTimeSeconds - new last update time. */ public void setAutoLastTime(long lastTimeSeconds) { this.valuesChanged = true; this.lastUpdateTime = lastTimeSeconds; } /** * Retrieve the unique name of the script engine to use for filtering. * * @return Script engine to use. */ public String getScriptEngineName() { return getGlobalValue(SCRIPT_ENGINE_NAME, "JavaScript"); } /** * Set the unique name of the script engine to use for filtering. * <p> * This setting will take effect next time ProtocolLib is started. * * @param name - name of the script engine to use. */ public void setScriptEngineName(String name) { setConfig(global, SCRIPT_ENGINE_NAME, name); modCount++; } /** * Retrieve the default injection method. * * @return Default method. */ public PlayerInjectHooks getDefaultMethod() { return PlayerInjectHooks.NETWORK_SERVER_OBJECT; } /** * Retrieve the injection method that has been set in the configuration, or use a default value. * * @return Injection method to use. * @throws IllegalArgumentException If the configuration option is malformed. */ public PlayerInjectHooks getInjectionMethod() throws IllegalArgumentException { String text = global.getString(INJECTION_METHOD); // Default hook if nothing has been set PlayerInjectHooks hook = getDefaultMethod(); if (text != null) hook = PlayerInjectHooks.valueOf(text.toUpperCase(Locale.ENGLISH).replace(" ", "_")); return hook; } /** * Set the starting injection method to use. * * @return Injection method. */ public void setInjectionMethod(PlayerInjectHooks hook) { setConfig(global, INJECTION_METHOD, hook.name()); modCount++; } /** * Retrieve the number of modifications made to this configuration. * * @return The number of modifications. */ public int getModificationCount() { return modCount; } /** * Save the current configuration file. */ public void saveAll() { if (valuesChanged) saveLastUpdate(lastUpdateTime); if (configChanged) plugin.saveConfig(); // And we're done valuesChanged = false; configChanged = false; } }