Java tutorial
/* * This file is part of UltimateCore, licensed under the MIT License (MIT). * * Copyright (c) Bammerbom * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ package bammerbom.ultimatecore.bukkit.configuration; import com.google.common.base.Charsets; import com.google.common.io.Files; import java.io.*; import java.nio.charset.Charset; import org.apache.commons.lang.Validate; import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder; /** * This is a base class for all File based implementations of {@link * Configuration} */ abstract class FileConfiguration extends MemoryConfiguration { protected static final boolean UTF8_OVERRIDE; protected static final boolean UTF_BIG; protected static final boolean SYSTEM_UTF; static { final byte[] testBytes = Base64Coder.decode( "ICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX4NCg=="); final String testString = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\r\n"; final Charset defaultCharset = Charset.defaultCharset(); final String resultString = new String(testBytes, defaultCharset); final boolean trueUTF = defaultCharset.name().contains("UTF"); UTF8_OVERRIDE = !testString.equals(resultString) || defaultCharset.equals(Charset.forName("US-ASCII")); SYSTEM_UTF = trueUTF || UTF8_OVERRIDE; UTF_BIG = trueUTF && UTF8_OVERRIDE; } /** * Creates an empty {@link FileConfiguration} with no default values. */ public FileConfiguration() { super(); } /** * Creates an empty {@link FileConfiguration} using the specified {@link * Configuration} as a source for all default values. * * @param defaults Default value provider */ public FileConfiguration(MemoryConfiguration defaults) { super(defaults); } /** * Saves this {@link FileConfiguration} to the specified location. * <p/> * If the file does not exist, it will be created. If already exists, it * will be overwritten. If it cannot be overwritten or created, an exception * will be thrown. * <p/> * This method will save using the system default encoding, or possibly * using UTF8. * * @param file File to save to. * @throws IOException Thrown when the given file cannot be written to for * any reason. * @throws IllegalArgumentException Thrown when file is null. */ public void save(File file) throws IOException { Validate.notNull(file, "File cannot be null"); Files.createParentDirs(file); String data = saveToString(); Writer writer = new OutputStreamWriter(new FileOutputStream(file), UTF8_OVERRIDE && !UTF_BIG ? Charsets.UTF_8 : Charset.defaultCharset()); try { writer.write(data); } finally { writer.close(); } } /** * Saves this {@link FileConfiguration} to the specified location. * <p/> * If the file does not exist, it will be created. If already exists, it * will be overwritten. If it cannot be overwritten or created, an exception * will be thrown. * <p/> * This method will save using the system default encoding, or possibly * using UTF8. * * @param file File to save to. * @throws IOException Thrown when the given file cannot be written to for * any reason. * @throws IllegalArgumentException Thrown when file is null. */ public void save(String file) throws IOException { Validate.notNull(file, "File cannot be null"); save(new File(file)); } /** * Saves this {@link FileConfiguration} to a string, and returns it. * * @return String containing this configuration. */ protected abstract String saveToString(); /** * Loads this {@link FileConfiguration} from the specified location. * <p/> * All the values contained within this configuration will be removed, * leaving only settings and defaults, and the new values will be loaded * from the given file. * <p/> * If the file cannot be loaded for any reason, an exception will be thrown. * <p/> * This will attempt to use the {@link Charset#defaultCharset()} for files, * unless {@link #UTF8_OVERRIDE} but not {@link #UTF_BIG} is specified. * * @param file File to load from. * @throws FileNotFoundException Thrown when the given file cannot be * opened. * @throws IOException Thrown when the given file cannot be read. * @throws InvalidConfigurationException Thrown when the given file is not a * valid Configuration. * @throws IllegalArgumentException Thrown when file is null. */ public void load(File file) throws FileNotFoundException, IOException, InvalidConfigurationException { Validate.notNull(file, "File cannot be null"); final FileInputStream stream = new FileInputStream(file); load(new InputStreamReader(stream, UTF8_OVERRIDE && !UTF_BIG ? Charsets.UTF_8 : Charset.defaultCharset())); } /** * Loads this {@link FileConfiguration} from the specified stream. * <p/> * All the values contained within this configuration will be removed, * leaving only settings and defaults, and the new values will be loaded * from the given stream. * <p/> * This will attempt to use the {@link Charset#defaultCharset()}, unless * {@link #UTF8_OVERRIDE} or {@link #UTF_BIG} is specified. * * @param stream Stream to load from * @throws IOException Thrown when the given file cannot be read. * @throws InvalidConfigurationException Thrown when the given file is not a * valid Configuration. * @throws IllegalArgumentException Thrown when stream is null. * @see #load(Reader) * @deprecated This does not consider encoding */ @Deprecated public void load(InputStream stream) throws IOException, InvalidConfigurationException { Validate.notNull(stream, "Stream cannot be null"); load(new InputStreamReader(stream, UTF8_OVERRIDE ? Charsets.UTF_8 : Charset.defaultCharset())); } /** * Loads this {@link FileConfiguration} from the specified reader. * <p/> * All the values contained within this configuration will be removed, * leaving only settings and defaults, and the new values will be loaded * from the given stream. * * @param reader the reader to load from * @throws IOException thrown when underlying reader throws an IOException * @throws InvalidConfigurationException thrown when the reader does not * represent a valid Configuration * @throws IllegalArgumentException thrown when reader is null */ public void load(Reader reader) throws IOException, InvalidConfigurationException { BufferedReader input = reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader); StringBuilder builder = new StringBuilder(); try { String line; while ((line = input.readLine()) != null) { builder.append(line); builder.append('\n'); } } finally { input.close(); } loadFromString(builder.toString()); } /** * Loads this {@link FileConfiguration} from the specified location. * <p/> * All the values contained within this configuration will be removed, * leaving only settings and defaults, and the new values will be loaded * from the given file. * <p/> * If the file cannot be loaded for any reason, an exception will be thrown. * * @param file File to load from. * @throws FileNotFoundException Thrown when the given file cannot be * opened. * @throws IOException Thrown when the given file cannot be read. * @throws InvalidConfigurationException Thrown when the given file is not a * valid Configuration. * @throws IllegalArgumentException Thrown when file is null. */ public void load(String file) throws FileNotFoundException, IOException, InvalidConfigurationException { Validate.notNull(file, "File cannot be null"); load(new File(file)); } /** * Loads this {@link FileConfiguration} from the specified string, as * opposed to from file. * <p/> * All the values contained within this configuration will be removed, * leaving only settings and defaults, and the new values will be loaded * from the given string. * <p/> * If the string is invalid in any way, an exception will be thrown. * * @param contents Contents of a Configuration to load. * @throws InvalidConfigurationException Thrown if the specified string is * invalid. * @throws IllegalArgumentException Thrown if contents is null. */ protected abstract void loadFromString(String contents) throws InvalidConfigurationException; /** * Compiles the header for this {@link FileConfiguration} and returns the * result. * <p/> * This will use the header from {@link #options()} -> {@link * FileConfigurationOptions#header()}, respecting the rules of {@link * FileConfigurationOptions#copyHeader()} if set. * * @return Compiled header */ protected abstract String buildHeader(); @Override public FileConfigurationOptions options() { if (options == null) { options = new FileConfigurationOptions(this); } return (FileConfigurationOptions) options; } }