diff options
51 files changed, 4387 insertions, 137 deletions
diff --git a/src/Java/miscutil/core/lib/CORE.java b/src/Java/miscutil/core/lib/CORE.java index 19ace0bf47..270ebee91c 100644 --- a/src/Java/miscutil/core/lib/CORE.java +++ b/src/Java/miscutil/core/lib/CORE.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; import miscutil.core.creative.AddToCreativeTab; +import miscutil.core.util.aeonbits.owner.ConfigFactory; import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; import miscutil.core.xmod.gregtech.api.interfaces.internal.IGregtech_RecipeAdder; import miscutil.core.xmod.gregtech.common.Meta_GT_Proxy; @@ -31,6 +32,7 @@ public class CORE { public static IIconRegister GT_BlockIcons, GT_ItemIcons; public static List<Runnable> GT_BlockIconload = new ArrayList<Runnable>(); public static final Class<AddToCreativeTab> TAB = AddToCreativeTab.class; + public static ConfigHandler cfg = ConfigFactory.create(ConfigHandler.class); /** * A List containing all the Materials, which are somehow in use by GT and therefor receive a specific Set of Items. */ diff --git a/src/Java/miscutil/core/lib/ConfigHandler.java b/src/Java/miscutil/core/lib/ConfigHandler.java new file mode 100644 index 0000000000..d8ec0d6ff9 --- /dev/null +++ b/src/Java/miscutil/core/lib/ConfigHandler.java @@ -0,0 +1,14 @@ +package miscutil.core.lib; + +import miscutil.core.util.aeonbits.owner.Config; + +public interface ConfigHandler extends Config{ + + @DefaultValue("false") + boolean debugMode(); + + @DefaultValue("true") + boolean disableEnderIOIntegration(); + + +} diff --git a/src/Java/miscutil/core/lib/LoadedMods.java b/src/Java/miscutil/core/lib/LoadedMods.java index 9ea04cfa1a..2412482f6b 100644 --- a/src/Java/miscutil/core/lib/LoadedMods.java +++ b/src/Java/miscutil/core/lib/LoadedMods.java @@ -53,7 +53,7 @@ public class LoadedMods { totalMods++; } - if (Loader.isModLoaded("EnderIO") == true){ + if (Loader.isModLoaded("EnderIO") == true && !CORE.cfg.disableEnderIOIntegration()){ EnderIO = true; Utils.LOG_INFO("Components enabled for: EnderIO"); totalMods++; diff --git a/src/Java/miscutil/core/recipe/Gregtech_Recipe_Adder.java b/src/Java/miscutil/core/recipe/Gregtech_Recipe_Adder.java new file mode 100644 index 0000000000..631d4d4bea --- /dev/null +++ b/src/Java/miscutil/core/recipe/Gregtech_Recipe_Adder.java @@ -0,0 +1,98 @@ +package miscutil.core.recipe; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_ModHandler; +import miscutil.core.util.Utils; +import miscutil.core.util.item.UtilsItems; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class Gregtech_Recipe_Adder { + + private static int euT; + private static int ticks; + private static ItemStack inputStack1; + private static ItemStack inputStack2; + private static ItemStack outputStack1; + private static ItemStack outputStack2; + + public static void addRecipe( + Item maceratorInput, int maceratorInputAmount1, + Item maceratorOutput, int maceratorOutputAmount1, + Item compressorInput, int compressorInputAmount1, + Item compressorOutput, int compressorOutputAmount1, + Item blastFurnaceInput, int blastFurnaceInputAmount1, + Item blastFurnaceOutput, int blastFurnaceOutputAmount1, + Item blastFurnaceInput2, int blastFurnaceInputAmount2, + Item blastFurnaceOutput2, int blastFurnaceOutputAmount2, + Item smeltingInput, int smeltingInputAmount1, + Item smeltingOutput, int smeltingOutputAmount1, + + int euPerTick, int timeInTicks, + boolean addMaceratorRecipe, boolean addCompressorRecipe, boolean addBlastFurnaceRecipe, int blastFurnaceTemp, boolean addSmeltingRecipe, boolean addMixerRecipe){ + euT = euPerTick; + ticks = timeInTicks; + + resetVars(); + if (addMaceratorRecipe){ + inputStack1 = UtilsItems.getSimpleStack(maceratorInput, maceratorInputAmount1); + outputStack1 = UtilsItems.getSimpleStack(maceratorOutput, maceratorOutputAmount1); + addMaceratorRecipe(inputStack1, outputStack1); + } + resetVars(); + if (addCompressorRecipe){ + inputStack1 = UtilsItems.getSimpleStack(compressorInput, compressorInputAmount1); + outputStack1 = UtilsItems.getSimpleStack(compressorOutput, compressorOutputAmount1); + addCompressorRecipe(inputStack1, outputStack1); + } + resetVars(); + if (addBlastFurnaceRecipe){ + inputStack1 = UtilsItems.getSimpleStack(blastFurnaceInput, blastFurnaceInputAmount1); + inputStack2 = UtilsItems.getSimpleStack(blastFurnaceInput2, blastFurnaceInputAmount2); + outputStack1 = UtilsItems.getSimpleStack(blastFurnaceOutput, blastFurnaceOutputAmount1); + outputStack2 = UtilsItems.getSimpleStack(blastFurnaceOutput2, blastFurnaceOutputAmount2); + addBlastFurnaceRecipe(inputStack1, inputStack2, outputStack1, outputStack2, blastFurnaceTemp); + } + resetVars(); + if (addSmeltingRecipe){ + inputStack1 = UtilsItems.getSimpleStack(smeltingInput, smeltingInputAmount1); + outputStack1 = UtilsItems.getSimpleStack(smeltingOutput, smeltingOutputAmount1); + addSmeltingRecipe(inputStack1, outputStack1); + } + resetVars(); + + } + + private static void resetVars(){ + inputStack1 = null; + inputStack2 = null; + outputStack1 = null; + outputStack2 = null; + } + + private static void addMaceratorRecipe(ItemStack input1, ItemStack output1){ + GT_ModHandler.addPulverisationRecipe(input1, output1); + } + + private static void addCompressorRecipe(ItemStack input1, ItemStack output1){ + GT_ModHandler.addCompressionRecipe(input1, output1); + } + + private static void addBlastFurnaceRecipe(ItemStack input1, ItemStack input2, ItemStack output1, ItemStack output2, int tempRequired){ + Utils.LOG_INFO("Registering Blast Furnace Recipes."); + GT_Values.RA.addBlastRecipe( + input1, + input2, + GT_Values.NF, GT_Values.NF, + output1, + output2, + ticks, + euT, + tempRequired); + } + + private static void addSmeltingRecipe(ItemStack input1, ItemStack output1){ + GT_ModHandler.addSmeltingRecipe(input1, output1); + } + +} diff --git a/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java b/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java index 4b5c2613b2..89e6f9a86b 100644 --- a/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java +++ b/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java @@ -29,6 +29,7 @@ public class RECIPES_GREGTECH { mixerRecipes(); extractorRecipes(); addFuels(); + blastFurnaceRecipes(); } private static void cokeOvenRecipes(){ @@ -118,17 +119,12 @@ public class RECIPES_GREGTECH { private static void distilleryRecipes(){ Utils.LOG_INFO("Registering Distillery/Distillation Tower Recipes."); - //Distillery GT_Values.RA.addDistilleryRecipe(ItemList.Circuit_Integrated.getWithDamage(0L, 4L, new Object[0]), FluidUtils.getFluidStack("air", 20000), FluidUtils.getFluidStack("helium", 1), 400, 30, false); GT_Values.RA.addDistillationTowerRecipe(FluidUtils.getFluidStack("air", 20000), FluidUtils.getFluidStackArray("helium", 1), null, 160, 60); } private static void addFuels(){ Utils.LOG_INFO("Registering New Fuels."); - //CORE.RA.addFuel(GT_ModHandler.getModItem("Minecraft", "bucket_lava", 1L, 1), null, 2800, 1); - //CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketRocket_fuel", 1L, 1), null, 2800, 0); - //CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketHootch", 1L, 1), null, 2800, 0); - //CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketFire_water", 1L, 1), null, 2800, 0); GT_Values.RA.addFuel(UtilsItems.simpleMetaStack("EnderIO:bucketFire_water", 0, 1), null, 120, 0); GT_Values.RA.addFuel(UtilsItems.simpleMetaStack("EnderIO:bucketRocket_fuel", 0, 1), null, 112, 0); GT_Values.RA.addFuel(UtilsItems.simpleMetaStack("EnderIO:bucketHootch", 0, 1), null, 36, 0); @@ -143,6 +139,7 @@ public class RECIPES_GREGTECH { } private static void extractorRecipes(){ + Utils.LOG_INFO("Registering Extractor Recipes."); GT_ModHandler.addExtractionRecipe(GregtechItemList.Battery_RE_EV_Sodium.get(1L, new Object[0]), ItemList.Battery_Hull_HV.get(4L, new Object[0])); GT_ModHandler.addExtractionRecipe(GregtechItemList.Battery_RE_EV_Cadmium.get(1L, new Object[0]), ItemList.Battery_Hull_HV.get(4L, new Object[0])); GT_ModHandler.addExtractionRecipe(GregtechItemList.Battery_RE_EV_Lithium.get(1L, new Object[0]), ItemList.Battery_Hull_HV.get(4L, new Object[0])); @@ -153,20 +150,37 @@ public class RECIPES_GREGTECH { } private static void blastFurnaceRecipes(){ + Utils.LOG_INFO("Registering Blast Furnace Recipes."); + GT_Values.RA.addBlastRecipe( - UtilsItems.getItemStackOfAmountFromOreDict("ingotTitanium", 1), - UtilsItems.getItemStackOfAmountFromOreDict("ingotUranium", 8), + UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 11028, 1), + UtilsItems.simpleMetaStack("gregtech:gt.metaitem.01", 11098, 1), GT_Values.NF, GT_Values.NF, - GT_OreDictUnificator.get(OrePrefixes.ingotHot, GT_Materials.Staballoy, 1L), + UtilsItems.getSimpleStack(ModItems.itemIngotStaballoy, 1), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Titanium, 1L), (int) Math.max(GT_Materials.Staballoy.getMass() / 80L, 1L) * GT_Materials.Staballoy.mBlastFurnaceTemp, 1000, GT_Materials.Staballoy.mBlastFurnaceTemp); - GT_Values.RA.addBlastRecipe( - UtilsItems.getItemStackOfAmountFromOreDict("dustStaballoy", 1), + UtilsItems.getSimpleStack(ModItems.itemDustStaballoy, 1), + null, + GT_Values.NF, GT_Values.NF, + UtilsItems.getSimpleStack(ModItems.itemIngotStaballoy, 1), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Titanium, 1L), + (int) Math.max(GT_Materials.Staballoy.getMass() / 80L, 1L) * GT_Materials.Staballoy.mBlastFurnaceTemp, + 2000, GT_Materials.Staballoy.mBlastFurnaceTemp); + GT_Values.RA.addBlastRecipe( + UtilsItems.getSimpleStack(ModItems.itemDustSmallStaballoy, 4), + null, + GT_Values.NF, GT_Values.NF, + UtilsItems.getSimpleStack(ModItems.itemIngotStaballoy, 1), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Titanium, 1L), + (int) Math.max(GT_Materials.Staballoy.getMass() / 80L, 1L) * GT_Materials.Staballoy.mBlastFurnaceTemp, + 2000, GT_Materials.Staballoy.mBlastFurnaceTemp); + GT_Values.RA.addBlastRecipe( + UtilsItems.getSimpleStack(ModItems.itemDustTinyStaballoy, 9), null, GT_Values.NF, GT_Values.NF, - GT_OreDictUnificator.get(OrePrefixes.ingotHot, GT_Materials.Staballoy, 1L), + UtilsItems.getSimpleStack(ModItems.itemIngotStaballoy, 1), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Titanium, 1L), (int) Math.max(GT_Materials.Staballoy.getMass() / 80L, 1L) * GT_Materials.Staballoy.mBlastFurnaceTemp, 2000, GT_Materials.Staballoy.mBlastFurnaceTemp); diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Accessible.java b/src/Java/miscutil/core/util/aeonbits/owner/Accessible.java new file mode 100644 index 0000000000..cbd770f4a8 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Accessible.java @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.io.IOException; +import java.io.OutputStream; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.util.Map; +import java.util.Set; + +/** + * <p>Allows a <tt>Config</tt> object to access the contents of the properties, providing utility methods to perform + * consequent operations.</p> + * <p>Example:</p> + * <pre> + * public interface MyConfig extends Config, Accessible { + * int someProperty(); + * } + * + * public void doSomething() { + * MyConfig cfg = ConfigFactory.create(MyConfig.class); + * cfg.list(System.out); + * } + * </pre> + * <p>These methods will print the list of properties, see {@link java.util.Properties#list(java.io.PrintStream)} and + * {@link java.util.Properties#list(java.io.PrintWriter)}.</p> + * + * @author Luigi R. Viggiano + * @since 1.0.4 + */ +public interface Accessible extends Config { + + /** + * Prints this property list out to the specified output stream. This method is useful for debugging. + * + * @param out an output stream. + * @throws ClassCastException if any key in this property list is not a string. + * @see java.util.Properties#list(java.io.PrintStream) + * @since 1.0.4 + */ + void list(PrintStream out); + + /** + * Prints this property list out to the specified output stream. This method is useful for debugging. + * + * @param out an output stream. + * @throws ClassCastException if any key in this property list is not a string. + * @see java.util.Properties#list(java.io.PrintWriter) + * @since 1.0.4 + */ + void list(PrintWriter out); + + /** + * Stores the underlying properties into an {@link java.io.OutputStream}. + * <p> + * Notice that method {@link java.util.Properties#store(java.io.Writer, String)} is not implemented since it's not + * available in JDK 1.5 (while the target of this library is Java 1.5+). + * + * @param out an output stream. + * @param comments a description of the property list. + * @throws IOException if writing this property list to the specified output stream throws an <tt>IOException</tt>. + * @see java.util.Properties#store(java.io.OutputStream, String) + * @since 1.0.4 + */ + void store(OutputStream out, String comments) throws IOException; + + /** + * Fills the given {@link java.util.Map} with the properties contained by this object. <br> + * This is useful to extract the content of the config object into a {@link java.util.Map}. + * <p> + * Notice that you can specify a properties object as parameter instead of a map, + * since {@link java.util.Properties} implements the {@link java.util.Map} interface. + * + * @param map the {@link java.util.Map} to fill. + * @since 1.0.9 + */ + void fill(Map map); + + /** + * Searches for the property with the specified key in this property list. + * If the key is not found in this property list, the default property list, + * and its defaults, recursively, are then checked. The method returns + * <code>null</code> if the property is not found. + * + * @param key the property key. + * @return the value in this property list with the specified key value. + * @see java.util.Properties#getProperty(String) + * @since 1.0.4 + */ + String getProperty(String key); + + /** + * Searches for the property with the specified key in this property list. + * If the key is not found in this property list, the default property list, + * and its defaults, recursively, are then checked. The method returns the + * default value argument if the property is not found. + * + * @param key the property key. + * @param defaultValue a default value. + * @return the value in this property list with the specified key value. + * @see java.util.Properties#getProperty(String, String) + * + * @since 1.0.4 + */ + String getProperty(String key, String defaultValue); + + /** + * Emits an XML document representing all of the properties contained + * in this table. + * + * <p> An invocation of this method of the form <tt>props.storeToXML(os, + * comment)</tt> behaves in exactly the same way as the invocation + * <tt>props.storeToXML(os, comment, "UTF-8");</tt>. + * + * @param os the output stream on which to emit the XML document. + * @param comment a description of the property list, or <code>null</code> + * if no comment is desired. + * @throws IOException if writing to the specified output stream + * results in an <tt>IOException</tt>. + * @throws NullPointerException if <code>os</code> is null. + * @throws ClassCastException if this <code>Properties</code> object + * contains any keys or values that are not + * <code>Strings</code>. + * @since 1.0.5 + */ + void storeToXML(OutputStream os, String comment) throws IOException; + + /** + * Returns a set of keys in this property list + * including distinct keys in the default property list if a key + * of the same name has not already been found from the main + * properties list. + * <p> + * The returned set is not backed by the <tt>Properties</tt> object. + * Changes to this <tt>Properties</tt> are not reflected in the set, + * or vice versa. + * + * @return a set of keys in this property list, including the keys in the + * default property list. + * @throws ClassCastException if any key in this property list + * is not a string. + * @see java.util.Properties#defaults + * @see java.util.Properties#stringPropertyNames() + * @see java.util.Properties#propertyNames() + * @since 1.0.5 + */ + Set<String> propertyNames(); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Config.java b/src/Java/miscutil/core/util/aeonbits/owner/Config.java new file mode 100644 index 0000000000..ab7fa23cc1 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Config.java @@ -0,0 +1,345 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + + +import java.io.IOException; +import java.io.Serializable; +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; +import java.net.URI; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.TimeUnit; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static java.util.concurrent.TimeUnit.SECONDS; +import static miscutil.core.util.aeonbits.owner.Config.HotReloadType.SYNC; +import static miscutil.core.util.aeonbits.owner.Config.LoadType.FIRST; +import static miscutil.core.util.aeonbits.owner.Util.ignore; +import static miscutil.core.util.aeonbits.owner.Util.reverse; + +/** + * Marker interface that must be implemented by all Config sub-interfaces. + * <p> + * Sub-interfaces may also extend {@link Accessible} to allow some debugging facility, or {@link Reloadable} to allow the + * user to programmatically reload properties. + * </p> + * + * @author Luigi R. Viggiano + * @see java.util.Properties + */ +public interface Config extends Serializable { + + /** + * Specifies the policy for loading the properties files. By default the first available properties file specified + * by {@link Sources} will be loaded, see {@link LoadType#FIRST}. User can also specify that the load policy is + * {@link LoadType#MERGE} to have the properties files merged: properties are loaded in order from the first file to + * the last, if there are conflicts in properties names the earlier files loaded prevail. + * + * @since 1.0.2 + */ + @Retention(RUNTIME) + @Target(TYPE) + @Documented + @interface LoadPolicy { + LoadType value() default FIRST; + } + + /** + * Specifies the source from which to load the properties file. It has to be specified in a URI string format. + * By default, allowed protocols are the ones allowed by {@link java.net.URL} plus + * <tt>classpath:path/to/resource.properties</tt>, but user can specify his own additional protocols. + * + * @since 1.0.2 + */ + @Retention(RUNTIME) + @Target(TYPE) + @Documented + @interface Sources { + String[] value(); + } + + /** + * Default value to be used if no property is found. No quoting (other than normal Java string quoting) is done. + */ + @Retention(RUNTIME) + @Target(METHOD) + @Documented + @interface DefaultValue { + String value(); + } + + /** + * The key used for lookup for the property. If not present, the key will be generated based on the unqualified + * method name. + */ + @Retention(RUNTIME) + @Target(METHOD) + @Documented + @interface Key { + String value(); + } + + /** + * Specifies the policy type to use to load the {@link miscutil.core.util.aeonbits.owner.Config.Sources} files for properties. + * + * @since 1.0.2 + */ + enum LoadType { + + /** + * The first available of the specified sources will be loaded. + */ + FIRST { + @Override + Properties load(List<URI> uris, LoadersManager loaders) { + Properties result = new Properties(); + for (URI uri : uris) + try { + loaders.load(result, uri); + break; + } catch (IOException ex) { + // happens when a file specified in the sources is not found or cannot be read. + ignore(); + } + return result; + } + }, + + /** + * All the specified sources will be loaded and merged. If the same property key is + * specified from more than one source, the one specified first will prevail. + */ + MERGE { + @Override + Properties load(List<URI> uris, LoadersManager loaders) { + Properties result = new Properties(); + for (URI uri : reverse(uris)) + try { + loaders.load(result, uri); + } catch (IOException ex) { + // happens when a file specified in the sources is not found or cannot be read. + ignore(); + } + return result; + } + }; + + abstract Properties load(List<URI> uris, LoadersManager loaders); + } + + /** + * Specify that the class implements hot reloading of properties from filesystem baked {@link Sources} (hot + * reloading can't be applied to all types of URIs). + * <p> + * It is possible to specify an interval to indicate how frequently the library shall check the files for + * modifications and perform the reload. + * </p> + * Examples: + * <pre> + * @HotReload // will check for file changes every 5 seconds. + * @Sources("file:foo/bar/baz.properties") + * interface MyConfig extends Config { ... } + * + * @HotReload(2) // will check for file changes every 2 seconds. + * @Sources("file:foo/bar/baz.properties") + * interface MyConfig extends Config { ... } + * + * @HotReload(500, unit = TimeUnit.MILLISECONDS); // will check for file changes every 500 milliseconds. + * @Sources("file:foo/bar/baz.properties") + * interface MyConfig extends Config { ... } + * + * @HotReload(type=HotReloadType.ASYNC); // will use ASYNC reload type: will span a separate thread + * // that will check for the file change every 5 seconds (default). + * @Sources("file:foo/bar/baz.properties") + * interface MyConfig extends Config { ... } + * + * @HotReload(2, type=HotReloadType.ASYNC); // will use ASYNC reload type and will check every 2 seconds. + * @Sources("file:foo/bar/baz.properties") + * interface MyConfig extends Config { ... } + * </pre> + * + * <p> + * To intercept the {@link miscutil.core.util.aeonbits.owner.event.ReloadEvent} see {@link Reloadable#addReloadListener(miscutil.core.util.aeonbits.owner.event.ReloadListener)}. + * + * @since 1.0.4 + */ + @Retention(RUNTIME) + @Target(TYPE) + @Documented + @interface HotReload { + /** + * The interval, expressed in seconds (by default), to perform checks on the filesystem to identify modified + * files and eventually perform the reloading of the properties. By default is 5 seconds. + * + * @return the hot reload value; default is 5. + */ + long value() default 5; + + /** + * <p> + * The time unit for the interval. By default it is {@link TimeUnit#SECONDS}. + * </p> + * <p> + * Date resolution vary from filesystem to filesystem.<br> + * For instance, for Ext3, ReiserFS and HSF+ the date resolution is of 1 second.<br> + * For FAT32 the date resolution for the last modified time is 2 seconds. <br> + * For Ext4 the date resolution is in nanoseconds. + * </p> + * <p> + * So, it is a good idea to express the time unit in seconds or more, since higher time resolution + * will probably not be supported by the underlying filesystem. + * </p> + * @return the time unit; default is SECONDS. + */ + TimeUnit unit() default SECONDS; + + /** + * The type of HotReload to use. It can be: + * + * <p> + * {@link HotReloadType#SYNC Synchronous}: the configuration file is checked when a method is invoked on the + * config object. So if the config object is not used for some time, the configuration doesn't get reloaded, + * until its next usage. i.e. until next method invocation. + * <p> + * {@link HotReloadType#ASYNC}: the configuration file is checked by a background thread despite the fact that + * the config object is used or not. + * + * @return the hot reload type; default is SYNC. + */ + HotReloadType type() default SYNC; + } + + /** + * Allows to specify which type of HotReload should be applied. + */ + enum HotReloadType { + /** + * The hot reload will happen when one of the methods is invoked on the <tt>Config</tt> class. + */ + SYNC, + + /** + * The hot reload will happen in background at the specified interval. + */ + ASYNC + } + + /** + * Specifies to disable some of the features supported by the API. + * This may be useful in case the user prefers to implement by his own, or just has troubles with something that + * is unwanted. + * Features that can be disabled are specified in the enum {@link DisableableFeature}. + * + * @since 1.0.4 + */ + @Retention(RUNTIME) + @Target({METHOD, TYPE}) + @Documented + @interface DisableFeature { + DisableableFeature[] value(); + } + + /** + * This enum contains the features that can be disabled using the annotation {@link DisableFeature}. + * + * @since 1.0.4 + */ + enum DisableableFeature { + VARIABLE_EXPANSION, + PARAMETER_FORMATTING + } + + /** + * Specifies simple <tt>{@link String}</tt> as separator to tokenize properties values specified as a + * single string value, into elements for vectors and collections. + * The value specified is used as per {@link String#split(String, int)} with int=-1, every element is also + * trimmed out from spaces using {@link String#trim()}. + * + * Notice that {@link TokenizerClass} and {@link Separator} do conflict with each-other when they are both specified + * together on the same level: + * <ul> + * <li> + * You cannot specify {@link TokenizerClass} and {@link Separator} both together on the same method + * </li> + * <li> + * You cannot specify {@link TokenizerClass} and {@link Separator} both together on the same class + * </li> + * </ul> + * in the two above cases an {@link UnsupportedOperationException} will be thrown when the corresponding conversion + * is executed. + * + * @since 1.0.4 + */ + @Retention(RUNTIME) + @Target({METHOD, TYPE}) + @Documented + @interface Separator { + /** + * @return the value specified is used as per {@link java.lang.String#split(String, int)} with int=-1 + */ + String value(); + } + + /** + * Specifies a <tt>{@link Tokenizer}</tt> class to allow the user to define a custom logic to split + * the property value into tokens to be used as single elements for vectors and collections. + * + * Notice that {@link TokenizerClass} and {@link Separator} do conflict with each-other when they are both specified + * together on the same level: + * <ul> + * <li> + * You cannot specify {@link TokenizerClass} and {@link Separator} both together on the same method + * </li> + * <li> + * You cannot specify {@link TokenizerClass} and {@link Separator} both together on the same class + * </li> + * </ul> + * in the two above cases an {@link UnsupportedOperationException} will be thrown when the corresponding conversion + * is executed. + * + * @since 1.0.4 + */ + @Retention(RUNTIME) + @Target({METHOD, TYPE}) + @Documented + @interface TokenizerClass { + Class<? extends Tokenizer> value(); + } + + /** + * Specifies a <tt>{@link Converter}</tt> class to allow the user to define a custom conversion logic for the + * type returned by the method. If the method returns a collection, the Converter is used to convert a single + * element. + */ + @Retention(RUNTIME) + @Target(METHOD) + @Documented + @interface ConverterClass { + Class<? extends Converter> value(); + } + + /** + * Specifies a <tt>{@link Preprocessor}</tt> class to allow the user to define a custom logic to pre-process + * the property value before being used by the library. + * + * @since 1.0.9 + */ + @Retention(RUNTIME) + @Target({METHOD, TYPE}) + @Documented + @interface PreprocessorClasses { + Class<? extends Preprocessor>[] value(); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/ConfigCache.java b/src/Java/miscutil/core/util/aeonbits/owner/ConfigCache.java new file mode 100644 index 0000000000..5a061e56f8 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/ConfigCache.java @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +/** + * Utility class caching Config instances that can be used as Singletons. + * + * This class is designed to be thread safe. + * + * @author Luigi R. Viggiano + * @since 1.0.6 + */ +public final class ConfigCache { + private static final ConcurrentMap<Object, Config> CACHE = new ConcurrentHashMap<Object, Config>(); + + /** Don't let anyone instantiate this class */ + private ConfigCache() {} + + /** + * Gets from the cache or create, an instance of the given class using the given imports. + * The factory used to create new instances is the static {@link ConfigFactory#INSTANCE}. + * + * @param clazz the interface extending from {@link Config} that you want to instantiate. + * @param imports additional variables to be used to resolve the properties. + * @param <T> type of the interface. + * @return an object implementing the given interface, that can be taken from the cache, + * which maps methods to property values. + */ + public static <T extends Config> T getOrCreate(Class<? extends T> clazz, Map<?, ?>... imports) { + return getOrCreate(ConfigFactory.INSTANCE, clazz, clazz, imports); + } + + /** + * Gets from the cache or create, an instance of the given class using the given imports. + * + * @param factory the factory to use to eventually create the instance. + * @param clazz the interface extending from {@link Config} that you want to instantiate. + * @param imports additional variables to be used to resolve the properties. + * @param <T> type of the interface. + * @return an object implementing the given interface, that can be taken from the cache, + * which maps methods to property values. + */ + public static <T extends Config> T getOrCreate(Factory factory, Class<? extends T> clazz, Map<?, ?>... imports) { + return getOrCreate(factory, clazz, clazz, imports); + } + + /** + * Gets from the cache or create, an instance of the given class using the given imports. + * The factory used to create new instances is the static {@link ConfigFactory#INSTANCE}. + * + * @param key the key object to be used to identify the instance in the cache. + * @param clazz the interface extending from {@link Config} that you want to instantiate. + * @param imports additional variables to be used to resolve the properties. + * @param <T> type of the interface. + * @return an object implementing the given interface, that can be taken from the cache, + * which maps methods to property values. + */ + public static <T extends Config> T getOrCreate(Object key, Class<? extends T> clazz, Map<?, ?>... imports) { + return getOrCreate(ConfigFactory.INSTANCE, key, clazz, imports); + } + + /** + * Gets from the cache or create, an instance of the given class using the given imports. + * + * @param factory the factory to use to eventually create the instance. + * @param key the key object to be used to identify the instance in the cache. + * @param clazz the interface extending from {@link Config} that you want to instantiate. + * @param imports additional variables to be used to resolve the properties. + * @param <T> type of the interface. + * @return an object implementing the given interface, that can be taken from the cache, + * which maps methods to property values. + */ + public static <T extends Config> T getOrCreate(Factory factory, Object key, + Class<? extends T> clazz, Map<?, ?>... imports) { + T existing = get(key); + if (existing != null) return existing; + T created = factory.create(clazz, imports); + T raced = add(key, created); + return raced != null ? raced : created; + } + + /** + * Gets from the cache the {@link Config} instance identified by the given key. + * + * @param key the key object to be used to identify the instance in the cache. + * @param <T> type of the interface. + * @return the {@link Config} object from the cache if exists, or <tt>null</tt> if it doesn't. + */ + @SuppressWarnings("unchecked") + public static <T extends Config> T get(Object key) { + return (T) CACHE.get(key); + } + + /** + * Adds a {@link Config} object into the cache. + * + * @param key the key object to be used to identify the instance in the cache. + * @param instance the instance of the {@link Config} object to be stored into the cache. + * @param <T> type of the interface. + * @return the previous value associated with the specified key, or + * <tt>null</tt> if there was no mapping for the key. + */ + @SuppressWarnings("unchecked") + public static <T extends Config> T add(Object key, T instance) { + return (T) CACHE.putIfAbsent(key, instance); + } + + /** + * Removes all of the cached instances. + * The cache will be empty after this call returns. + */ + public static void clear() { + CACHE.clear(); + } + + /** + * Removes the cached instance for the given key if it is present. + * + * <p>Returns previous instance associated to the given key in the cache, + * or <tt>null</tt> if the cache contained no instance for the given key. + * + * <p>The cache will not contain the instance for the specified key once the + * call returns. + * + * @param <T> type of the interface. + * @param key key whose instance is to be removed from the cache. + * @return the previous instance associated with <tt>key</tt>, or + * <tt>null</tt> if there was no instance for <tt>key</tt>. + */ + @SuppressWarnings("unchecked") + public static <T extends Config> T remove(Object key) { + return (T) CACHE.remove(key); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/ConfigFactory.java b/src/Java/miscutil/core/util/aeonbits/owner/ConfigFactory.java new file mode 100644 index 0000000000..f138c6665b --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/ConfigFactory.java @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.util.Map; +import java.util.Properties; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ThreadFactory; + +import miscutil.core.util.aeonbits.owner.loaders.Loader; +import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor; + +/** + * A static factory class to instantiate {@link Config} instances. + * <p> + * By default a {@link Config} sub-interface is associated to a property having the same package name and class name as + * the interface itself.</p> + * <p> + * Method names are mapped to property names contained in the property files.</p> + * <p> + * This is a singleton static class, to be used as convenience when only a single factory is needed inside an + * application. It exposes the {@link #newInstance()} method to create new instances of {@link Factory} objects. + * </p> + * @author Luigi R. Viggiano + */ +public final class ConfigFactory { + + static final Factory INSTANCE = newInstance(); + + /** Don't let anyone instantiate this class */ + private ConfigFactory() {} + + /** + * Returns a new instance of a config Factory object. + * + * @return a new instance of a config Factory object. + */ + public static Factory newInstance() { + ScheduledExecutorService scheduler = newSingleThreadScheduledExecutor(new ThreadFactory() { + public Thread newThread(Runnable r) { + Thread result = new Thread(r); + result.setDaemon(true); + return result; + } + }); + Properties props = new Properties(); + return new DefaultFactory(scheduler, props); + } + + /** + * Creates a {@link Config} instance from the specified interface + * + * @param clazz the interface extending from {@link Config} that you want to instantiate. + * @param imports additional variables to be used to resolve the properties. + * @param <T> type of the interface. + * @return an object implementing the given interface, which maps methods to property values. + */ + public static <T extends Config> T create(Class<? extends T> clazz, Map<?, ?>... imports) { + return INSTANCE.create(clazz, imports); + } + + /** + * Set a property in the ConfigFactory. Those properties will be used to expand variables specified in the `@Source` + * annotation, or by the ConfigFactory to configure its own behavior. + * + * @param key the key for the property. + * @param value the value for the property. + * @return the old value. + * @since 1.0.4 + */ + public static String setProperty(String key, String value) { + return INSTANCE.setProperty(key, value); + } + + /** + * Those properties will be used to expand variables specified in the `@Source` annotation, or by the ConfigFactory + * to configure its own behavior. + * + * @return the properties in the ConfigFactory + * @since 1.0.4 + */ + public static Properties getProperties() { + return INSTANCE.getProperties(); + } + + /** + * Those properties will be used to expand variables specified in the `@Source` annotation, or by the ConfigFactory + * to configure its own behavior. + * + * @param properties the properties to set in the config Factory. + * @since 1.0.4 + */ + public static void setProperties(Properties properties) { + INSTANCE.setProperties(properties); + } + + /** + * Returns the value for a given property. + * + * @param key the key for the property + * @return the value for the property, or <tt>null</tt> if the property is not set. + * @since 1.0.4 + */ + public static String getProperty(String key) { + return INSTANCE.getProperty(key); + } + + /** + * Clears the value for the property having the given key. This means, that the given property is removed. + * + * @param key the key for the property to remove. + * @return the old value for the given key, or <tt>null</tt> if the property was not set. + * @since 1.0.4 + */ + public static String clearProperty(String key) { + return INSTANCE.clearProperty(key); + } + + /** + * Registers a loader to enables additional file formats. + * + * @param loader the loader to register. + * @throws NullPointerException if specified loader is <tt>null</tt>. + * @since 1.0.5 + */ + public static void registerLoader(Loader loader) { + INSTANCE.registerLoader(loader); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/ConfigURIFactory.java b/src/Java/miscutil/core/util/aeonbits/owner/ConfigURIFactory.java new file mode 100644 index 0000000000..40d54b656b --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/ConfigURIFactory.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URL; + +import static miscutil.core.util.aeonbits.owner.Util.fixBackslashesToSlashes; + +/** + * @author Luigi R. Viggiano + */ +class ConfigURIFactory { + + private static final String CLASSPATH_PROTOCOL = "classpath:"; + private final transient ClassLoader classLoader; + private final VariablesExpander expander; + + ConfigURIFactory(ClassLoader classLoader, VariablesExpander expander) { + this.classLoader = classLoader; + this.expander = expander; + } + + URI newURI(String spec) throws URISyntaxException { + String expanded = expand(spec); + String fixed = fixBackslashesToSlashes(expanded); + if (fixed.startsWith(CLASSPATH_PROTOCOL)) { + String path = fixed.substring(CLASSPATH_PROTOCOL.length()); + URL url = classLoader.getResource(path); + if (url == null) + return null; + return url.toURI(); + } else { + return new URI(fixed); + } + } + + private String expand(String path) { + return expander.expand(path); + } + + String toClasspathURLSpec(String name) { + return CLASSPATH_PROTOCOL + name.replace('.', '/'); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Converter.java b/src/Java/miscutil/core/util/aeonbits/owner/Converter.java new file mode 100644 index 0000000000..d460d74565 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Converter.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.lang.reflect.Method; + +/** + * Converter interface specifies how to convert an input string coming from a property value to a target object returned + * by the Config method. + * + * @param <T> the type of the class that should be returned from the conversion. + * @author Luigi R. Viggiano + * @since 1.0.4 + */ +public interface Converter<T> { + + /** + * Converts the given input into an Object of type T. + * If the method returns null, null will be returned by the Config object. + * The converter is instantiated for every call, so it shouldn't have any internal state. + * + * @param method the method invoked on the <tt>{@link Config} object</tt> + * @param input the property value specified as input text to be converted to the T return type + * @return the object of type T converted from the input string. + * @since 1.0.4 + */ + T convert(Method method, String input); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Converters.java b/src/Java/miscutil/core/util/aeonbits/owner/Converters.java new file mode 100644 index 0000000000..fcc8723a39 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Converters.java @@ -0,0 +1,314 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.beans.PropertyEditor; +import java.beans.PropertyEditorManager; +import java.io.File; +import java.lang.reflect.Array; +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.lang.reflect.ParameterizedType; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; +import java.util.SortedSet; +import java.util.TreeSet; + +import miscutil.core.util.aeonbits.owner.Config.ConverterClass; +import static java.lang.reflect.Modifier.isStatic; +import static miscutil.core.util.aeonbits.owner.Converters.SpecialValue.NULL; +import static miscutil.core.util.aeonbits.owner.Converters.SpecialValue.SKIP; +import static miscutil.core.util.aeonbits.owner.Util.expandUserHome; +import static miscutil.core.util.aeonbits.owner.Util.unreachableButCompilerNeedsThis; +import static miscutil.core.util.aeonbits.owner.Util.unsupported; +import static miscutil.core.util.aeonbits.owner.util.Reflection.isClassAvailable; + +/** + * Converter class from {@link java.lang.String} to property types. + * + * @author Luigi R. Viggiano + */ +enum Converters { + + ARRAY { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + if (!targetType.isArray()) return SKIP; + + Class<?> type = targetType.getComponentType(); + + if (text.trim().isEmpty()) + return Array.newInstance(type, 0); + + Tokenizer tokenizer = TokenizerResolver.resolveTokenizer(targetMethod); + String[] chunks = tokenizer.tokens(text); + + Converters converter = doConvert(targetMethod, type, chunks[0]).getConverter(); + Object result = Array.newInstance(type, chunks.length); + + for (int i = 0; i < chunks.length; i++) { + String chunk = chunks[i]; + Object value = converter.tryConvert(targetMethod, type, chunk); + Array.set(result, i, value); + } + + return result; + } + }, + + COLLECTION { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + if (!Collection.class.isAssignableFrom(targetType)) return SKIP; + + Object[] array = convertToArray(targetMethod, text); + Collection<Object> collection = Arrays.asList(array); + Collection<Object> result = instantiateCollection(targetType); + result.addAll(collection); + return result; + } + + private Object[] convertToArray(Method targetMethod, String text) { + Class<?> type = getGenericType(targetMethod); + Object stub = Array.newInstance(type, 0); + return (Object[]) ARRAY.tryConvert(targetMethod, stub.getClass(), text); + } + + private Class<?> getGenericType(Method targetMethod) { + if (targetMethod.getGenericReturnType() instanceof ParameterizedType) { + ParameterizedType parameterizedType = (ParameterizedType) targetMethod.getGenericReturnType(); + return (Class<?>) parameterizedType.getActualTypeArguments()[0]; + } + // Default generic type for raw collections. + return String.class; + } + + private <T> Collection<T> instantiateCollection(Class<? extends T> targetType) { + if (targetType.isInterface()) + return instantiateCollectionFromInterface(targetType); + return instantiateCollectionFromClass(targetType); + } + + @SuppressWarnings("unchecked") + private <T> Collection<T> instantiateCollectionFromClass(Class<? extends T> targetType) { + try { + return (Collection<T>) targetType.newInstance(); + } catch (Exception e) { + throw unsupported(e, "Cannot instantiate collection of type '%s'", targetType.getCanonicalName()); + } + } + + private <T> Collection<T> instantiateCollectionFromInterface(Class<? extends T> targetType) { + if (List.class.isAssignableFrom(targetType)) + return new ArrayList<T>(); + else if (SortedSet.class.isAssignableFrom(targetType)) + return new TreeSet<T>(); + else if (Set.class.isAssignableFrom(targetType)) + return new LinkedHashSet<T>(); + return new ArrayList<T>(); + } + + }, + + METHOD_WITH_CONVERTER_CLASS_ANNOTATION { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + ConverterClass annotation = targetMethod.getAnnotation(ConverterClass.class); + if (annotation == null) return SKIP; + + Class<? extends Converter> converterClass = annotation.value(); + Converter<?> converter; + try { + converter = converterClass.newInstance(); + } catch (InstantiationException e) { + throw unsupported(e, "Converter class %s can't be instantiated: %s", + converterClass.getCanonicalName(), e.getMessage()); + } catch (IllegalAccessException e) { + throw unsupported(e, "Converter class %s can't be accessed: %s", + converterClass.getCanonicalName(), e.getMessage()); + } + Object result = converter.convert(targetMethod, text); + if (result == null) return NULL; + return result; + } + }, + + PROPERTY_EDITOR { + + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + if (!canUsePropertyEditors()) + return SKIP; + + PropertyEditor editor = PropertyEditorManager.findEditor(targetType); + if (editor == null) return SKIP; + try { + editor.setAsText(text); + return editor.getValue(); + } catch (Exception e) { + throw unsupportedConversion(e, targetType, text); + } + } + + private boolean canUsePropertyEditors() { + return isPropertyEditorAvailable() && !isPropertyEditorDisabled(); + } + + private boolean isPropertyEditorAvailable() { + return isClassAvailable("java.beans.PropertyEditorManager"); + } + + private boolean isPropertyEditorDisabled() { + return Boolean.getBoolean("org.aeonbits.owner.property.editor.disabled"); + } + }, + + /* + * This is needed for cases like when the PropertyEditor classes are not available + */ + PRIMITIVE { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + if (! targetType.isPrimitive()) return SKIP; + if (targetType == Byte.TYPE) return Byte.parseByte(text); + if (targetType == Short.TYPE) return Short.parseShort(text); + if (targetType == Integer.TYPE) return Integer.parseInt(text); + if (targetType == Long.TYPE) return Long.parseLong(text); + if (targetType == Boolean.TYPE) return Boolean.parseBoolean(text); + if (targetType == Float.TYPE) return Float.parseFloat(text); + if (targetType == Double.TYPE) return Double.parseDouble(text); + return SKIP; + } + }, + + FILE { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + if (targetType != File.class) return SKIP; + return new File(expandUserHome(text)); + } + }, + + CLASS { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + if (targetType != Class.class) return SKIP; + try { + return Class.forName(text); + } catch (ClassNotFoundException ex) { + throw unsupported(ex, CANNOT_CONVERT_MESSAGE, text, targetType.getCanonicalName()); + } + } + }, + + CLASS_WITH_STRING_CONSTRUCTOR { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + try { + Constructor<?> constructor = targetType.getConstructor(String.class); + return constructor.newInstance(text); + } catch (Exception e) { + return SKIP; + } + } + }, + + CLASS_WITH_VALUE_OF_METHOD { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + try { + Method method = targetType.getMethod("valueOf", String.class); + if (isStatic(method.getModifiers())) + return method.invoke(null, text); + return SKIP; + } catch (Exception e) { + return SKIP; + } + } + }, + + CLASS_WITH_OBJECT_CONSTRUCTOR { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + try { + Constructor<?> constructor = targetType.getConstructor(Object.class); + return constructor.newInstance(text); + } catch (Exception e) { + return SKIP; + } + } + }, + + UNSUPPORTED { + @Override + Object tryConvert(Method targetMethod, Class<?> targetType, String text) { + throw unsupportedConversion(targetType, text); + } + }; + + abstract Object tryConvert(Method targetMethod, Class<?> targetType, String text); + + static Object convert(Method targetMethod, Class<?> targetType, String text) { + return doConvert(targetMethod, targetType, text).getConvertedValue(); + } + + private static ConversionResult doConvert(Method targetMethod, Class<?> targetType, String text) { + for (Converters converter : values()) { + Object convertedValue = converter.tryConvert(targetMethod, targetType, text); + if (convertedValue != SKIP) + return new ConversionResult(converter, convertedValue); + } + return unreachableButCompilerNeedsThis(); + } + + private static UnsupportedOperationException unsupportedConversion(Exception cause, Class<?> targetType, String text) { + return unsupported(cause, CANNOT_CONVERT_MESSAGE, text, targetType.getCanonicalName()); + } + + private static UnsupportedOperationException unsupportedConversion(Class<?> targetType, String text) { + return unsupported(CANNOT_CONVERT_MESSAGE, text, targetType.getCanonicalName()); + } + + private static class ConversionResult { + private final Converters converter; + private final Object convertedValue; + + public ConversionResult(Converters converter, Object convertedValue) { + this.converter = converter; + this.convertedValue = convertedValue; + } + + public Converters getConverter() { + return converter; + } + + public Object getConvertedValue() { + return convertedValue; + } + } + + enum SpecialValue { + /** + * The NULL object: when tryConvert returns this object, the conversion result is null. + */ + NULL, + + /** + * The SKIP object: when tryConvert returns this object the conversion is skipped in favour of the next one. + */ + SKIP + } + + static final String CANNOT_CONVERT_MESSAGE = "Cannot convert '%s' to %s"; + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/DefaultFactory.java b/src/Java/miscutil/core/util/aeonbits/owner/DefaultFactory.java new file mode 100644 index 0000000000..694a62f022 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/DefaultFactory.java @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import javax.management.DynamicMBean; + +import miscutil.core.util.aeonbits.owner.loaders.Loader; + +import java.util.Map; +import java.util.Properties; +import java.util.concurrent.ScheduledExecutorService; + +import static java.lang.reflect.Proxy.newProxyInstance; +import static miscutil.core.util.aeonbits.owner.util.Reflection.isClassAvailable; + +/** + * Default implementation for {@link Factory}. + * + * @author Luigi R. Viggiano + */ +class DefaultFactory implements Factory { + + private static final boolean isJMXAvailable = isClassAvailable("javax.management.DynamicMBean"); + private final ScheduledExecutorService scheduler; + private Properties props; + final LoadersManager loadersManager; + + DefaultFactory(ScheduledExecutorService scheduler, Properties props) { + this.scheduler = scheduler; + this.props = props; + this.loadersManager = new LoadersManager(); + } + + @SuppressWarnings("unchecked") + public <T extends Config> T create(Class<? extends T> clazz, Map<?, ?>... imports) { + Class<?>[] interfaces = interfaces(clazz); + VariablesExpander expander = new VariablesExpander(props); + PropertiesManager manager = new PropertiesManager(clazz, new Properties(), scheduler, expander, loadersManager, + imports); + Object jmxSupport = getJMXSupport(clazz, manager); + PropertiesInvocationHandler handler = new PropertiesInvocationHandler(manager, jmxSupport); + T proxy = (T) newProxyInstance(clazz.getClassLoader(), interfaces, handler); + handler.setProxy(proxy); + return proxy; + } + + public String setProperty(String key, String value) { + checkKey(key); + return (String) props.setProperty(key, value); + } + + private void checkKey(String key) { + if (key == null) + throw new IllegalArgumentException("key can't be null"); + if (key.isEmpty()) + throw new IllegalArgumentException("key can't be empty"); + } + + public Properties getProperties() { + return props; + } + + public void setProperties(Properties properties) { + if (properties == null) + props = new Properties(); + else + props = properties; + } + + public void registerLoader(Loader loader) { + loadersManager.registerLoader(loader); + } + + public String getProperty(String key) { + checkKey(key); + return props.getProperty(key); + } + + public String clearProperty(String key) { + checkKey(key); + return (String) props.remove(key); + } + + private Object getJMXSupport(Class<?> clazz, PropertiesManager manager) { + if (isJMXAvailable) + return new JMXSupport(clazz, manager); + return null; + } + + private <T extends Config> Class<?>[] interfaces(Class<? extends T> clazz) { + if (isJMXAvailable) + return new Class<?>[]{clazz, DynamicMBean.class}; + else + return new Class<?>[]{clazz}; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Delegate.java b/src/Java/miscutil/core/util/aeonbits/owner/Delegate.java new file mode 100644 index 0000000000..6b5e378769 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Delegate.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +@Retention(RUNTIME) +@Target(METHOD) +@interface Delegate { +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/DelegateMethodHandle.java b/src/Java/miscutil/core/util/aeonbits/owner/DelegateMethodHandle.java new file mode 100644 index 0000000000..9c22958e8a --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/DelegateMethodHandle.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Arrays; + +/** + * @author Luigi R. Viggiano + */ +class DelegateMethodHandle { + private final Object target; + private final Method method; + + public DelegateMethodHandle(Object target, Method method) { + this.target = target; + this.method = method; + } + + public Object invoke(Object[] args) throws Throwable { + try { + return method.invoke(target, args); + } catch (InvocationTargetException e) { + throw e.getTargetException(); + } + } + + public boolean matches(Method invokedMethod) { + return invokedMethod.getName().equals(method.getName()) + && invokedMethod.getReturnType().equals(method.getReturnType()) + && Arrays.equals(invokedMethod.getParameterTypes(), method.getParameterTypes()); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Factory.java b/src/Java/miscutil/core/util/aeonbits/owner/Factory.java new file mode 100644 index 0000000000..06a3e5d85a --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Factory.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.util.Map; +import java.util.Properties; + +import miscutil.core.util.aeonbits.owner.loaders.Loader; + +/** + * Interface for factory implementation used to instantiate {@link Config} instances. + * + * @author Luigi R. Viggiano + * @since 1.0.5 + */ +public interface Factory { + + /** + * Creates a {@link Config} instance from the specified interface + * + * @param clazz the interface extending from {@link Config} that you want to instantiate. + * @param imports additional variables to be used to resolve the properties. + * @param <T> type of the interface. + * @return an object implementing the given interface, which maps methods to property values. + * @since 1.0.5 + */ + <T extends Config> T create(Class<? extends T> clazz, Map<?, ?>... imports); + + /** + * Returns the value for a given property. + * + * @param key the key for the property + * @return the value for the property, or <tt>null</tt> if the property is not set. + * @since 1.0.5 + */ + String getProperty(String key); + + /** + * Set a property in the ConfigFactory. Those properties will be used to expand variables specified in the `@Source` + * annotation, or by the ConfigFactory to configure its own behavior. + * + * @param key the key for the property. + * @param value the value for the property. + * @return the old value. + * @since 1.0.5 + */ + String setProperty(String key, String value); + + /** + * Clears the value for the property having the given key. This means, that the given property is removed. + * + * @param key the key for the property to remove. + * @return the old value for the given key, or <tt>null</tt> if the property was not set. + * @since 1.0.5 + */ + String clearProperty(String key); + + /** + * Those properties will be used to expand variables specified in the `@Source` annotation, or by the ConfigFactory + * to configure its own behavior. + * + * @return the properties in the ConfigFactory + * @since 1.0.5 + */ + Properties getProperties(); + + /** + * Those properties will be used to expand variables specified in the `@Source` annotation, or by the ConfigFactory + * to configure its own behavior. + * + * @param properties the properties to set in the config Factory. + * @since 1.0.5 + */ + void setProperties(Properties properties); + + /** + * Registers a loader to enables additional file formats. + * + * @param loader the loader to register. + * @throws NullPointerException if specified loader is <tt>null</tt>. + * @since 1.0.5 + */ + void registerLoader(Loader loader); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/HotReloadLogic.java b/src/Java/miscutil/core/util/aeonbits/owner/HotReloadLogic.java new file mode 100644 index 0000000000..49870b17c6 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/HotReloadLogic.java @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.io.File; +import java.io.Serializable; +import java.net.URI; +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +import miscutil.core.util.aeonbits.owner.Config.HotReload; +import miscutil.core.util.aeonbits.owner.Config.HotReloadType; +import static miscutil.core.util.aeonbits.owner.Config.HotReloadType.ASYNC; +import static miscutil.core.util.aeonbits.owner.Config.HotReloadType.SYNC; +import static miscutil.core.util.aeonbits.owner.Util.fileFromURI; +import static miscutil.core.util.aeonbits.owner.Util.now; + +/** + * @author Luigi R. Viggiano + */ +class HotReloadLogic implements Serializable { + + private final PropertiesManager manager; + private final long interval; + private final HotReloadType type; + private volatile long lastCheckTime = now(); + private final List<WatchableFile> watchableFiles = new ArrayList<WatchableFile>(); + + private static class WatchableFile implements Serializable { + private final File file; + private long lastModifiedTime; + + WatchableFile(File file) { + this.file = file; + this.lastModifiedTime = file.lastModified(); + } + + public boolean isChanged() { + long lastModifiedTimeNow = file.lastModified(); + boolean changed = lastModifiedTime != lastModifiedTimeNow; + if (changed) + lastModifiedTime = lastModifiedTimeNow; + return changed; + } + } + + public HotReloadLogic(HotReload hotReload, List<URI> uris, PropertiesManager manager) { + this.manager = manager; + type = hotReload.type(); + interval = hotReload.unit().toMillis(hotReload.value()); + setupWatchableResources(uris); + } + + private void setupWatchableResources(List<URI> uris) { + Set<File> files = new LinkedHashSet<File>(); + for (URI uri : uris) { + File file = fileFromURI(uri); + if (file != null) + files.add(file); + } + for (File file : files) + watchableFiles.add(new WatchableFile(file)); + } + + synchronized void checkAndReload() { + if (needsReload()) + manager.reload(); + } + + private boolean needsReload() { + if (manager.isLoading()) return false; + + long now = now(); + if (now < lastCheckTime + interval) + return false; + + try { + for (WatchableFile resource : watchableFiles) + if (resource.isChanged()) + return true; + return false; + } finally { + lastCheckTime = now; + } + } + + boolean isAsync() { + return type == ASYNC; + } + + boolean isSync() { + return type == SYNC; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/JMXSupport.java b/src/Java/miscutil/core/util/aeonbits/owner/JMXSupport.java new file mode 100644 index 0000000000..1e3a5ccbe8 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/JMXSupport.java @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import javax.management.Attribute; +import javax.management.AttributeList; +import javax.management.AttributeNotFoundException; +import javax.management.InvalidAttributeValueException; +import javax.management.MBeanAttributeInfo; +import javax.management.MBeanException; +import javax.management.MBeanInfo; +import javax.management.MBeanOperationInfo; +import javax.management.MBeanParameterInfo; +import javax.management.ReflectionException; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + +/** + * @author Robin Meißner + * @author Luigi R. Viggiano + */ +class JMXSupport implements Serializable { + + private final Class<?> clazz; + private final PropertiesManager manager; + + public JMXSupport(Class<?> clazz, PropertiesManager manager) { + this.clazz = clazz; + this.manager = manager; + } + + @Delegate + public Object getAttribute(String attribute) + throws AttributeNotFoundException, MBeanException, + ReflectionException { + return manager.getProperty(attribute); + } + + @Delegate + public void setAttribute(Attribute attribute) + throws AttributeNotFoundException, InvalidAttributeValueException, + MBeanException, ReflectionException { + manager.setProperty(attribute.getName(), (String) attribute.getValue()); + } + + @Delegate + public AttributeList getAttributes(String[] attributes) { + List<Attribute> attrList = new LinkedList<Attribute>(); + for (String propertyName : attributes) + attrList.add(new Attribute(propertyName, manager.getProperty(propertyName))); + return new AttributeList(attrList); + } + + @Delegate + public AttributeList setAttributes(AttributeList attributes) { + for (Attribute attr : attributes.asList()) + manager.setProperty(attr.getName(), (String) attr.getValue()); + return attributes; + } + + @Delegate + public Object invoke(String actionName, Object[] params, String[] signature) + throws MBeanException, ReflectionException { + if (actionName.equals("getProperty") && params != null && params.length == 1) { + return manager.getProperty((String) params[0]); + } else if (actionName.equals("setProperty") && params != null && params.length == 2) { + manager.setProperty((String) params[0], (String) params[1]); + return null; + } else if (actionName.equals("reload") && (params == null || params.length == 0)) { + manager.reload(); + return null; + } + throw new ReflectionException(new NoSuchMethodException(actionName)); + } + + @Delegate + public MBeanInfo getMBeanInfo() { + List<MBeanAttributeInfo> attributesInfo = new ArrayList<MBeanAttributeInfo>(); + Set<String> propertyNames = manager.propertyNames(); + for (String name : propertyNames) + attributesInfo.add(new MBeanAttributeInfo(name, "java.lang.String", name, true, true, false)); + + MBeanAttributeInfo[] attributes = attributesInfo.toArray(new MBeanAttributeInfo[propertyNames.size()]); + + MBeanParameterInfo key = new MBeanParameterInfo("key", "java.lang.String", "Key of the property"); + MBeanParameterInfo value = new MBeanParameterInfo("value", "java.lang.String", "Value of the property"); + + MBeanOperationInfo[] operations = new MBeanOperationInfo[] { + new MBeanOperationInfo("getProperty", "Gets value for a property", + new MBeanParameterInfo[] { key }, "java.lang.String", MBeanOperationInfo.INFO), + new MBeanOperationInfo("setProperty", "Sets the value for a property", + new MBeanParameterInfo[] { key, value }, "void", MBeanOperationInfo.ACTION), + new MBeanOperationInfo("reload", "Reload properties", null, "void", MBeanOperationInfo.ACTION) + }; + + return new MBeanInfo(clazz.getName(), clazz.getSimpleName() + " OWNER MBean", + attributes, null, operations, null); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/LoadersManager.java b/src/Java/miscutil/core/util/aeonbits/owner/LoadersManager.java new file mode 100644 index 0000000000..d3f05d0c45 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/LoadersManager.java @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.io.IOException; +import java.io.Serializable; +import java.net.URI; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +import miscutil.core.util.aeonbits.owner.loaders.Loader; +import miscutil.core.util.aeonbits.owner.loaders.PropertiesLoader; +import miscutil.core.util.aeonbits.owner.loaders.XMLLoader; +import static miscutil.core.util.aeonbits.owner.Util.unsupported; + + +/** + * This class is responsible of locating an appropriate Loader for a given URL (based the extension in the resource + * name)and load the properties from it. + * + * @author Luigi R. Viggiano + * @since 1.0.5 + */ +class LoadersManager implements Serializable { + + private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + private final List<Loader> loaders = new LinkedList<Loader>(); + + LoadersManager() { + registerLoader(new PropertiesLoader()); + registerLoader(new XMLLoader()); + } + + void load(Properties result, URI uri) throws IOException { + Loader loader = findLoader(uri); + loader.load(result, uri); + } + + Loader findLoader(URI uri) { + lock.readLock().lock(); + try { + for (Loader loader : loaders) + if (loader.accept(uri)) + return loader; + throw unsupported("Can't resolve a Loader for the URL %s.", uri.toString()); + } finally { + lock.readLock().unlock(); + } + } + + final void registerLoader(Loader loader) { + if (loader == null) + throw new IllegalArgumentException("loader can't be null"); + lock.writeLock().lock(); + try { + loaders.add(0, loader); + } finally { + lock.writeLock().unlock(); + } + } + + void clear() { + lock.writeLock().lock(); + try{ + loaders.clear(); + } finally { + lock.writeLock().unlock(); + } + } + + String[] defaultSpecs(String prefix) { + lock.readLock().lock(); + try { + List<String> defaultSpecs = new ArrayList<String>(loaders.size()); + for (Loader loader : loaders) { + String spec = loader.defaultSpecFor(prefix); + if (spec != null) + defaultSpecs.add(spec); + } + return defaultSpecs.toArray(new String[0]); + } finally { + lock.readLock().unlock(); + } + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Mutable.java b/src/Java/miscutil/core/util/aeonbits/owner/Mutable.java new file mode 100644 index 0000000000..72a9c582e3 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Mutable.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.beans.PropertyChangeListener; +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; + +/** + * <p>Allows a <tt>Config</tt> object to change its property values at runtime.</p> + * <p>Example:</p> + * <pre> + * public interface MyConfig extends Config, Mutable { + * @DefaultValue("18") + * int minAge(); + * } + * + * public void example() { + * MyConfig cfg = ConfigFactory.create(MyConfig.class); + * int before = cfg.minAge(); // before = 18 + * int old = cfg.setProperty("minAge", "21"); // old = 18 + * int after = cfg.minAge(); // after = 21 + * int old2 = cfg.removeProperty("minAge"); // old2 = 21 + * int end = cfg.minAge(); // end = null + * } + * </pre> + * + * @author Luigi R. Viggiano + * @since 1.0.4 + */ +public interface Mutable extends Config { + + /** + * <p>Sets a given property to the specified value.</p> + * <p>Differently than {@link + * java.util.Properties#setProperty(String, String)}, if <tt>key</tt> is set to <tt>null</tt> then this call is + * equivalent to {@link #removeProperty(String)}.</p> + * + * @param key the key to be placed into the property list. + * @param value the value corresponding to <tt>key</tt>, or <tt>null</tt> if the property must be removed. + * @return the previous value of the specified key, or <code>null</code> if it did not have one. + * @since 1.0.4 + */ + String setProperty(String key, String value); + + /** + * Removes a given property. + * + * @param key the key of the property to remove. + * @return the previous value of the specified key, or <code>null</code> if it did not have one. + * @see java.util.Hashtable#remove(Object) + * @since 1.0.4 + */ + String removeProperty(String key); + + /** + * Clears all properties. + * + * @since 1.0.4 + */ + void clear(); + + /** + * Reads a property list (key and element pairs) from the input byte stream. + * + * @param inStream the input stream. + * @throws java.io.IOException if an error occurred when reading from the input stream. + * @throws IllegalArgumentException if the input stream contains a malformed Unicode escape sequence. + * @see java.util.Properties#load(java.io.InputStream) + * @since 1.0.4 + */ + void load(InputStream inStream) throws IOException; + + /** + * Reads a property list (key and element pairs) from the input character stream in a simple line-oriented format. + * + * @param reader the input character stream. + * @throws IOException if an error occurred when reading from the input stream. + * @throws IllegalArgumentException if a malformed Unicode escape appears in the input. + * @see java.util.Properties#load(java.io.Reader) + * @since 1.0.4 + */ + void load(Reader reader) throws IOException; + + /** + * Adds a {@link PropertyChangeListener} to the Mutable interface. + * + * @param listener the listener to be added. + * @since 1.0.5 + */ + void addPropertyChangeListener(PropertyChangeListener listener); + + /** + * Removes a {@link PropertyChangeListener} from the Mutable interface. + * + * @param listener the property change listener to be removed + */ + void removePropertyChangeListener(PropertyChangeListener listener); + + /** + * Adds a PropertyChangeListener to the listener list for a specific + * property. + * If <code>propertyName</code> or <code>listener</code> is <code>null</code>, + * no exception is thrown and no action is taken. + * + * @param propertyName one of the property names listed above + * @param listener the property change listener to be added + */ + void addPropertyChangeListener(String propertyName, PropertyChangeListener listener); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Preprocessor.java b/src/Java/miscutil/core/util/aeonbits/owner/Preprocessor.java new file mode 100644 index 0000000000..ad09741d07 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Preprocessor.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +/** + * Preprocessor interface specifies how to pre-process an input string coming from a property value before being used by + * OWNER. + * + * @author Luigi R. Viggiano + * @since 1.0.9 + */ +public interface Preprocessor { + String process(String input); +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/PreprocessorResolver.java b/src/Java/miscutil/core/util/aeonbits/owner/PreprocessorResolver.java new file mode 100644 index 0000000000..20be663c71 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/PreprocessorResolver.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +import miscutil.core.util.aeonbits.owner.Config.PreprocessorClasses; +import static java.util.Collections.emptyList; +import static miscutil.core.util.aeonbits.owner.Util.newInstance; + +/** + * @author Luigi R. Viggiano + */ +final class PreprocessorResolver { + + /** Don't let anyone instantiate this class */ + private PreprocessorResolver() {} + + public static List<Preprocessor> resolvePreprocessors(Method method) { + List<Preprocessor> result = new ArrayList<Preprocessor>(); + List<Preprocessor> preprocessorsOnMethod = getPreprocessor(method.getAnnotation(PreprocessorClasses.class)); + result.addAll(preprocessorsOnMethod); + + List<Preprocessor> preprocessorsOnClass = getPreprocessor(method.getDeclaringClass().getAnnotation(PreprocessorClasses.class)); + result.addAll(preprocessorsOnClass); + + return result; + } + + private static List<Preprocessor> getPreprocessor(PreprocessorClasses preprocessorClassesAnnotation) { + if (preprocessorClassesAnnotation == null) return emptyList(); + Class<? extends Preprocessor>[] preprocessorClasses = preprocessorClassesAnnotation.value(); + if (preprocessorClasses == null) return emptyList(); + List<Preprocessor> result = new LinkedList<Preprocessor>(); + return newInstance(preprocessorClassesAnnotation.value(), result); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/PropertiesInvocationHandler.java b/src/Java/miscutil/core/util/aeonbits/owner/PropertiesInvocationHandler.java new file mode 100644 index 0000000000..4a51f5e86e --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/PropertiesInvocationHandler.java @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.io.IOException; +import java.io.Serializable; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.LinkedList; +import java.util.List; + +import static miscutil.core.util.aeonbits.owner.Config.DisableableFeature.PARAMETER_FORMATTING; +import static miscutil.core.util.aeonbits.owner.Config.DisableableFeature.VARIABLE_EXPANSION; +import static miscutil.core.util.aeonbits.owner.Converters.convert; +import static miscutil.core.util.aeonbits.owner.Converters.SpecialValue.NULL; +import static miscutil.core.util.aeonbits.owner.PreprocessorResolver.resolvePreprocessors; +import static miscutil.core.util.aeonbits.owner.PropertiesMapper.key; +import static miscutil.core.util.aeonbits.owner.Util.isFeatureDisabled; +import static miscutil.core.util.aeonbits.owner.util.Reflection.invokeDefaultMethod; +import static miscutil.core.util.aeonbits.owner.util.Reflection.isDefault; + +/** + * This {@link InvocationHandler} receives method calls from the delegate instantiated by {@link ConfigFactory} and maps + * it to a property value from a property file, or a {@link Config.DefaultValue} specified in method annotation. + * <p> + * The {@link Config.Key} annotation can be used to override default mapping between method names and property names. + * </p> + * <p> + * Automatic conversion is handled between the property value and the return type expected by the method of the + * delegate. + * </p> + * + * @author Luigi R. Viggiano + */ +class PropertiesInvocationHandler implements InvocationHandler, Serializable { + + private static final long serialVersionUID = 5432212884255718342L; + private transient List<DelegateMethodHandle> delegates; + private final Object jmxSupport; + private final StrSubstitutor substitutor; + final PropertiesManager propertiesManager; + + + PropertiesInvocationHandler(PropertiesManager manager, Object jmxSupport) { + this.propertiesManager = manager; + this.jmxSupport = jmxSupport; + delegates = findDelegates(manager, jmxSupport); + this.substitutor = new StrSubstitutor(manager.load()); + } + + public Object invoke(Object proxy, Method invokedMethod, Object... args) throws Throwable { + propertiesManager.syncReloadCheck(); + + if (isDefault(invokedMethod)) + return invokeDefaultMethod(proxy, invokedMethod, args); + + DelegateMethodHandle delegate = getDelegateMethod(invokedMethod); + if (delegate != null) + return delegate.invoke(args); + + return resolveProperty(invokedMethod, args); + } + + private DelegateMethodHandle getDelegateMethod(Method invokedMethod) { + for (DelegateMethodHandle delegate : delegates) + if (delegate.matches(invokedMethod)) + return delegate; + return null; + } + + private Object resolveProperty(Method method, Object... args) { + String key = expandKey(method); + String value = propertiesManager.getProperty(key); + if (value == null && !isFeatureDisabled(method, VARIABLE_EXPANSION)) { // TODO: this if should go away! See #84 and #86 + String unexpandedKey = key(method); + value = propertiesManager.getProperty(unexpandedKey); + } + if (value == null) + return null; + value = preProcess(method, value); + Object result = convert(method, method.getReturnType(), format(method, expandVariables(method, value), args)); + if (result == NULL) return null; + return result; + } + + private String preProcess(Method method, String value) { + List<Preprocessor> preprocessors = resolvePreprocessors(method); + String result = value; + for (Preprocessor preprocessor : preprocessors) + result = preprocessor.process(result); + return result; + } + + private String expandKey(Method method) { + String key = key(method); + if (isFeatureDisabled(method, VARIABLE_EXPANSION)) + return key; + return substitutor.replace(key); + } + + private String format(Method method, String format, Object... args) { + if (isFeatureDisabled(method, PARAMETER_FORMATTING)) + return format; + return String.format(format, args); + } + + private String expandVariables(Method method, String value) { + if (isFeatureDisabled(method, VARIABLE_EXPANSION)) + return value; + return substitutor.replace(value); + } + + private List<DelegateMethodHandle> findDelegates(Object... targets) { + List<DelegateMethodHandle> result = new LinkedList<DelegateMethodHandle>(); + for (Object target : targets) { + if (target == null) + continue; + Method[] methods = target.getClass().getMethods(); + for (Method m : methods) + if (m.getAnnotation(Delegate.class) != null) + result.add(new DelegateMethodHandle(target, m)); + } + return result; + } + + public <T extends Config> void setProxy(T proxy) { + propertiesManager.setProxy(proxy); + } + + private void readObject(java.io.ObjectInputStream in) + throws IOException, ClassNotFoundException { + in.defaultReadObject(); + delegates = findDelegates(propertiesManager, jmxSupport); + } +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/PropertiesManager.java b/src/Java/miscutil/core/util/aeonbits/owner/PropertiesManager.java new file mode 100644 index 0000000000..075ae2c35f --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/PropertiesManager.java @@ -0,0 +1,584 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.io.Reader; +import java.io.Serializable; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Proxy; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Set; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock; +import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock; + +import miscutil.core.util.aeonbits.owner.event.ReloadEvent; +import miscutil.core.util.aeonbits.owner.event.ReloadListener; +import miscutil.core.util.aeonbits.owner.event.RollbackBatchException; +import miscutil.core.util.aeonbits.owner.event.RollbackException; +import miscutil.core.util.aeonbits.owner.event.RollbackOperationException; +import miscutil.core.util.aeonbits.owner.event.TransactionalPropertyChangeListener; +import miscutil.core.util.aeonbits.owner.event.TransactionalReloadListener; +import static java.util.Collections.synchronizedList; +import static miscutil.core.util.aeonbits.owner.Config.LoadType.FIRST; +import static miscutil.core.util.aeonbits.owner.PropertiesMapper.defaults; +import static miscutil.core.util.aeonbits.owner.Util.asString; +import static miscutil.core.util.aeonbits.owner.Util.eq; +import static miscutil.core.util.aeonbits.owner.Util.ignore; +import static miscutil.core.util.aeonbits.owner.Util.reverse; +import static miscutil.core.util.aeonbits.owner.Util.unsupported; + +/** + * Loads properties and manages access to properties handling concurrency. + * + * @author Luigi R. Viggiano + */ +class PropertiesManager implements Reloadable, Accessible, Mutable { + + private final Class<? extends Config> clazz; + private final Map<?, ?>[] imports; + private final Properties properties; + private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + private final ReadLock readLock = lock.readLock(); + private final WriteLock writeLock = lock.writeLock(); + + private final LoadType loadType; + private final List<URI> uris; + private final HotReloadLogic hotReloadLogic; + + private volatile boolean loading = false; + + final List<ReloadListener> reloadListeners = synchronizedList(new LinkedList<ReloadListener>()); + + private Object proxy; + private final LoadersManager loaders; + + final List<PropertyChangeListener> propertyChangeListeners = synchronizedList( + new LinkedList<PropertyChangeListener>() { + @Override + public boolean remove(Object o) { + Iterator iterator = iterator(); + while (iterator.hasNext()) { + Object item = iterator.next(); + if (item.equals(o)) { + iterator.remove(); + return true; + } + } + return false; + } + }); + + PropertiesManager(Class<? extends Config> clazz, Properties properties, ScheduledExecutorService scheduler, + VariablesExpander expander, LoadersManager loaders, Map<?, ?>... imports) { + this.clazz = clazz; + this.properties = properties; + this.loaders = loaders; + this.imports = imports; + + ConfigURIFactory urlFactory = new ConfigURIFactory(clazz.getClassLoader(), expander); + uris = toURIs(clazz.getAnnotation(Sources.class), urlFactory); + + LoadPolicy loadPolicy = clazz.getAnnotation(LoadPolicy.class); + loadType = (loadPolicy != null) ? loadPolicy.value() : FIRST; + + HotReload hotReload = clazz.getAnnotation(HotReload.class); + if (hotReload != null) { + hotReloadLogic = new HotReloadLogic(hotReload, uris, this); + + if (hotReloadLogic.isAsync()) + scheduler.scheduleAtFixedRate(new Runnable() { + public void run() { + hotReloadLogic.checkAndReload(); + } + }, hotReload.value(), hotReload.value(), hotReload.unit()); + } else { + hotReloadLogic = null; + } + } + + private List<URI> toURIs(Sources sources, ConfigURIFactory uriFactory) { + String[] specs = specs(sources, uriFactory); + List<URI> result = new ArrayList<URI>(); + for (String spec : specs) { + try { + URI uri = uriFactory.newURI(spec); + if (uri != null) + result.add(uri); + } catch (URISyntaxException e) { + throw unsupported(e, "Can't convert '%s' to a valid URI", spec); + } + } + return result; + } + + private String[] specs(Sources sources, ConfigURIFactory uriFactory) { + if (sources != null) return sources.value(); + return defaultSpecs(uriFactory); + } + + private String[] defaultSpecs(ConfigURIFactory uriFactory) { + String prefix = uriFactory.toClasspathURLSpec(clazz.getName()); + return loaders.defaultSpecs(prefix); + } + + Properties load() { + writeLock.lock(); + try { + return load(properties); + } finally { + writeLock.unlock(); + } + } + + private Properties load(Properties props) { + try { + loading = true; + defaults(props, clazz); + Properties loadedFromFile = doLoad(); + merge(props, loadedFromFile); + merge(props, reverse(imports)); + return props; + } finally { + loading = false; + } + } + + @Delegate + public void reload() { + writeLock.lock(); + try { + Properties loaded = load(new Properties()); + List<PropertyChangeEvent> events = + fireBeforePropertyChangeEvents(keys(properties, loaded), properties, loaded); + ReloadEvent reloadEvent = fireBeforeReloadEvent(events, properties, loaded); + applyPropertyChangeEvents(events); + firePropertyChangeEvents(events); + fireReloadEvent(reloadEvent); + } catch (RollbackBatchException e) { + ignore(); + } finally { + writeLock.unlock(); + } + } + + private Set<?> keys(Map<?, ?>... maps) { + Set<Object> keys = new HashSet<Object>(); + for (Map<?, ?> map : maps) + keys.addAll(map.keySet()); + return keys; + } + + private void applyPropertyChangeEvents(List<PropertyChangeEvent> events) { + for (PropertyChangeEvent event : events) + performSetProperty(event.getPropertyName(), event.getNewValue()); + } + + private void fireReloadEvent(ReloadEvent reloadEvent) { + for (ReloadListener listener : reloadListeners) + listener.reloadPerformed(reloadEvent); + } + + private ReloadEvent fireBeforeReloadEvent(List<PropertyChangeEvent> events, Properties oldProperties, + Properties newProperties) throws RollbackBatchException { + ReloadEvent reloadEvent = new ReloadEvent(proxy, events, oldProperties, newProperties); + for (ReloadListener listener : reloadListeners) + if (listener instanceof TransactionalReloadListener) + ((TransactionalReloadListener) listener).beforeReload(reloadEvent); + return reloadEvent; + } + + + @Delegate + public void addReloadListener(ReloadListener listener) { + if (listener != null) + reloadListeners.add(listener); + } + + @Delegate + public void removeReloadListener(ReloadListener listener) { + if (listener != null) + reloadListeners.remove(listener); + } + + @Delegate + public void addPropertyChangeListener(PropertyChangeListener listener) { + if (listener != null) + propertyChangeListeners.add(listener); + } + + @Delegate + public void removePropertyChangeListener(PropertyChangeListener listener) { + if (listener != null) + propertyChangeListeners.remove(listener); + } + + @Delegate + public void addPropertyChangeListener(final String propertyName, final PropertyChangeListener listener) { + if (propertyName == null || listener == null) return; + + final boolean transactional = listener instanceof TransactionalPropertyChangeListener; + propertyChangeListeners.add(new PropertyChangeListenerWrapper(propertyName, listener, transactional)); + } + + private static class PropertyChangeListenerWrapper implements TransactionalPropertyChangeListener, Serializable { + + private final String propertyName; + private final PropertyChangeListener listener; + private final boolean transactional; + + public PropertyChangeListenerWrapper(String propertyName, PropertyChangeListener listener, + boolean transactional) { + this.propertyName = propertyName; + this.listener = listener; + this.transactional = transactional; + + } + + public void beforePropertyChange(PropertyChangeEvent event) throws RollbackOperationException, + RollbackBatchException { + if (transactional && propertyNameMatches(event)) + ((TransactionalPropertyChangeListener) listener).beforePropertyChange(event); + } + + private boolean propertyNameMatches(PropertyChangeEvent event) { + return propertyName.equals(event.getPropertyName()); + } + + public void propertyChange(PropertyChangeEvent event) { + if (propertyNameMatches(event)) + listener.propertyChange(event); + } + + @Override + public boolean equals(Object obj) { + return listener.equals(obj); + } + + @Override + public int hashCode() { + return listener.hashCode(); + } + } + + Properties doLoad() { + return loadType.load(uris, loaders); + } + + private static void merge(Properties results, Map<?, ?>... inputs) { + for (Map<?, ?> input : inputs) + results.putAll(input); + } + + @Delegate + public String getProperty(String key) { + readLock.lock(); + try { + return properties.getProperty(key); + } finally { + readLock.unlock(); + } + } + + void syncReloadCheck() { + if (hotReloadLogic != null && hotReloadLogic.isSync()) + hotReloadLogic.checkAndReload(); + } + + @Delegate + public String getProperty(String key, String defaultValue) { + readLock.lock(); + try { + return properties.getProperty(key, defaultValue); + } finally { + readLock.unlock(); + } + } + + @Delegate + public void storeToXML(OutputStream os, String comment) throws IOException { + readLock.lock(); + try { + properties.storeToXML(os, comment); + } finally { + readLock.unlock(); + } + } + + @Delegate + public Set<String> propertyNames() { + readLock.lock(); + try { + LinkedHashSet<String> result = new LinkedHashSet<String>(); + for (Enumeration<?> propertyNames = properties.propertyNames(); propertyNames.hasMoreElements(); ) + result.add((String) propertyNames.nextElement()); + return result; + } finally { + readLock.unlock(); + } + } + + @Delegate + public void list(PrintStream out) { + readLock.lock(); + try { + properties.list(out); + } finally { + readLock.unlock(); + } + } + + @Delegate + public void list(PrintWriter out) { + readLock.lock(); + try { + properties.list(out); + } finally { + readLock.unlock(); + } + } + + @Delegate + public void store(OutputStream out, String comments) throws IOException { + readLock.lock(); + try { + properties.store(out, comments); + } finally { + readLock.unlock(); + } + } + + @Delegate + public void fill(Map map) { + readLock.lock(); + try { + for (String propertyName : propertyNames()) + map.put(propertyName, getProperty(propertyName)); + } finally { + readLock.unlock(); + } + } + + @Delegate + public String setProperty(String key, String newValue) { + writeLock.lock(); + try { + String oldValue = properties.getProperty(key); + try { + if (eq(oldValue, newValue)) return oldValue; + + PropertyChangeEvent event = new PropertyChangeEvent(proxy, key, oldValue, newValue); + fireBeforePropertyChange(event); + String result = performSetProperty(key, newValue); + firePropertyChange(event); + return result; + } catch (RollbackException e) { + return oldValue; + } + } finally { + writeLock.unlock(); + } + } + + private String performSetProperty(String key, Object value) { + return (value == null) ? + performRemoveProperty(key) : + asString(properties.setProperty(key, asString(value))); + } + + @Delegate + public String removeProperty(String key) { + writeLock.lock(); + try { + String oldValue = properties.getProperty(key); + String newValue = null; + PropertyChangeEvent event = new PropertyChangeEvent(proxy, key, oldValue, newValue); + fireBeforePropertyChange(event); + String result = performRemoveProperty(key); + firePropertyChange(event); + return result; + } catch (RollbackException e) { + return properties.getProperty(key); + } finally { + writeLock.unlock(); + } + } + + private String performRemoveProperty(String key) { + return asString(properties.remove(key)); + } + + @Delegate + public void clear() { + writeLock.lock(); + try { + List<PropertyChangeEvent> events = + fireBeforePropertyChangeEvents(keys(properties), properties, new Properties()); + applyPropertyChangeEvents(events); + firePropertyChangeEvents(events); + } catch (RollbackBatchException e) { + ignore(); + } finally { + writeLock.unlock(); + } + } + + @Delegate + public void load(InputStream inStream) throws IOException { + writeLock.lock(); + try { + Properties loaded = new Properties(); + loaded.load(inStream); + performLoad(keys(loaded), loaded); + } catch (RollbackBatchException ex) { + ignore(); + } finally { + writeLock.unlock(); + } + } + + private void performLoad(Set keys, Properties props) throws RollbackBatchException { + List<PropertyChangeEvent> events = fireBeforePropertyChangeEvents(keys, properties, props); + applyPropertyChangeEvents(events); + firePropertyChangeEvents(events); + } + + @Delegate + public void load(Reader reader) throws IOException { + writeLock.lock(); + try { + Properties loaded = new Properties(); + loaded.load(reader); + performLoad(keys(loaded), loaded); + } catch (RollbackBatchException ex) { + ignore(); + } finally { + writeLock.unlock(); + } + } + + void setProxy(Object proxy) { + this.proxy = proxy; + } + + @Delegate + @Override + public String toString() { + readLock.lock(); + try { + return properties.toString(); + } finally { + readLock.unlock(); + } + } + + boolean isLoading() { + return loading; + } + + private List<PropertyChangeEvent> fireBeforePropertyChangeEvents( + Set keys, Properties oldValues, Properties newValues) throws RollbackBatchException { + List<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>(); + for (Object keyObject : keys) { + String key = (String) keyObject; + String oldValue = oldValues.getProperty(key); + String newValue = newValues.getProperty(key); + if (!eq(oldValue, newValue)) { + PropertyChangeEvent event = + new PropertyChangeEvent(proxy, key, oldValue, newValue); + try { + fireBeforePropertyChange(event); + events.add(event); + } catch (RollbackOperationException e) { + ignore(); + } + } + } + return events; + } + + private void firePropertyChangeEvents(List<PropertyChangeEvent> events) { + for (PropertyChangeEvent event : events) + firePropertyChange(event); + } + + private void fireBeforePropertyChange(PropertyChangeEvent event) throws RollbackBatchException, + RollbackOperationException { + for (PropertyChangeListener listener : propertyChangeListeners) + if (listener instanceof TransactionalPropertyChangeListener) + ((TransactionalPropertyChangeListener) listener).beforePropertyChange(event); + } + + private void firePropertyChange(PropertyChangeEvent event) { + for (PropertyChangeListener listener : propertyChangeListeners) + listener.propertyChange(event); + } + + @Delegate + @Override + public boolean equals(Object obj) { + if (!(obj instanceof Proxy)) return false; + InvocationHandler handler = Proxy.getInvocationHandler(obj); + if (!(handler instanceof PropertiesInvocationHandler)) + return false; + PropertiesInvocationHandler propsInvocationHandler = (PropertiesInvocationHandler) handler; + PropertiesManager that = propsInvocationHandler.propertiesManager; + return this.equals(that); + } + + private boolean equals(PropertiesManager that) { + if (!this.isAssignationCompatibleWith(that)) + return false; + this.readLock.lock(); + try { + that.readLock.lock(); + try { + return this.properties.equals(that.properties); + } finally { + that.readLock.unlock(); + } + } finally { + this.readLock.unlock(); + } + } + + private boolean isAssignationCompatibleWith(PropertiesManager that) { + return this.clazz.isAssignableFrom(that.clazz) || that.clazz.isAssignableFrom(this.clazz); + } + + @Delegate + @Override + public int hashCode() { + readLock.lock(); + try { + return properties.hashCode(); + } finally { + readLock.unlock(); + } + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/PropertiesMapper.java b/src/Java/miscutil/core/util/aeonbits/owner/PropertiesMapper.java new file mode 100644 index 0000000000..9e4ddf2ce2 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/PropertiesMapper.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.lang.reflect.Method; +import java.util.Properties; + +import miscutil.core.util.aeonbits.owner.Config.DefaultValue; +import miscutil.core.util.aeonbits.owner.Config.Key; + +/** + * Maps methods to properties keys and defaultValues. Maps a class to default property values. + * + * @author Luigi R. Viggiano + */ +final class PropertiesMapper { + + /** Don't let anyone instantiate this class */ + private PropertiesMapper() {} + + static String key(Method method) { + Key key = method.getAnnotation(Key.class); + return (key == null) ? method.getName() : key.value(); + } + + static String defaultValue(Method method) { + DefaultValue defaultValue = method.getAnnotation(DefaultValue.class); + return defaultValue != null ? defaultValue.value() : null; + } + + static void defaults(Properties properties, Class<? extends Config> clazz) { + Method[] methods = clazz.getMethods(); + for (Method method : methods) { + String key = key(method); + String value = defaultValue(method); + if (value != null) + properties.put(key, value); + } + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Reloadable.java b/src/Java/miscutil/core/util/aeonbits/owner/Reloadable.java new file mode 100644 index 0000000000..802405592c --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Reloadable.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import miscutil.core.util.aeonbits.owner.event.ReloadListener; + +/** + * <p>Allows a <tt>Config</tt> object to implement the reloading of the properties at runtime.</p> + * + * <p>Example:</p> + * + * <pre> + * public interface MyConfig extends Config, Reloadable { + * int someProperty(); + * } + * + * public void doSomething() { + * + * // loads the properties from the files for the first time. + * MyConfig cfg = ConfigFactory.create(MyConfig.class); + * int before = cfg.someProperty(); + * + * // after changing the local files... + * cfg.reload(); + * int after = cfg.someProperty(); + * + * // before and after may differ now. + * if (before != after) { ... } + * } + * </pre> + * + * <p>The reload method will reload the properties using the same sources used when it was instantiated the first time. + * This can be useful to programmatically reload the configuration after the configuration files were changed.</p> + * + * @author Luigi R. Viggiano + * @since 1.0.4 + */ +public interface Reloadable extends Config { + + /** + * Reloads the properties using the same logic as when the object was instantiated by {@link + * ConfigFactory#create(Class, java.util.Map[])}. + * + * @since 1.0.4 + */ + void reload(); + + /** + * Add a ReloadListener. + * @param listener the listener to be added + * + * @since 1.0.4 + */ + void addReloadListener(ReloadListener listener); + + /** + * Remove a ReloadListener. + * @param listener the listener to be removed + * + * @since 1.0.4 + */ + void removeReloadListener(ReloadListener listener); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/SplitAndTrimTokenizer.java b/src/Java/miscutil/core/util/aeonbits/owner/SplitAndTrimTokenizer.java new file mode 100644 index 0000000000..2dde1791e4 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/SplitAndTrimTokenizer.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +/** + * Tokenizer implementation based on {@link String#split(String, int)} and {@link String#trim()}. + * This class is used to implement <tt>tokenizer</tt>s for the {@link Config.Separator} annotation. + * + * @since 1.0.4 + * @author Luigi R. Viggiano + */ +class SplitAndTrimTokenizer implements Tokenizer { + + private final String regex; + + public SplitAndTrimTokenizer(String regex) { + this.regex = regex; + } + + public String[] tokens(String values) { + String[] chunks = values.split(regex, -1); + for(int i = 0; i < chunks.length; i++) + chunks[i] = chunks[i].trim(); + return chunks; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/StrSubstitutor.java b/src/Java/miscutil/core/util/aeonbits/owner/StrSubstitutor.java new file mode 100644 index 0000000000..017e465787 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/StrSubstitutor.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.io.Serializable; +import java.util.Properties; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static java.util.regex.Pattern.compile; +import static miscutil.core.util.aeonbits.owner.Util.fixBackslashForRegex; + +/** + * <p> + * Substitutes variables within a string by values. + * </p> + * <p> + * This class takes a piece of text and substitutes all the variables within it. The definition of a variable is + * <code>${variableName}</code>. + * </p> + * <p> + * Typical usage of this class follows the following pattern: First an instance is created and initialized with the + * values that contains the values for the available variables. If a prefix and/or suffix for variables should be used + * other than the default ones, the appropriate settings can be performed. After that the <code>replace()</code> method + * can be called passing in the source text for interpolation. In the returned text all variable references (as long as + * their values are known) will be resolved. The following example demonstrates this: + * </p> + * <pre> + * Map valuesMap = new HashMap(); + * valuesMap.put("animal", "quick brown fox"); + * valuesMap.put("target", "lazy dog"); + * String templateString = "The ${animal} jumped over the ${target}."; + * StrSubstitutor sub = new StrSubstitutor(valuesMap); + * String resolvedString = sub.replace(templateString); + * </pre> + * yielding: + * <pre> + * The quick brown fox jumped over the lazy dog. + * </pre> + * + * @author Luigi R. Viggiano + */ +class StrSubstitutor implements Serializable { + + private final Properties values; + private static final Pattern PATTERN = compile("\\$\\{(.+?)\\}"); + + /** + * Creates a new instance and initializes it. Uses defaults for variable prefix and suffix and the escaping + * character. + * + * @param values the variables' values, may be null + */ + StrSubstitutor(Properties values) { + this.values = values; + } + + /** + * Replaces all the occurrences of variables with their matching values from the resolver using the given source + * string as a template. + * + * @param source the string to replace in, null returns null + * @return the result of the replace operation + */ + String replace(String source) { + if (source == null) + return null; + Matcher m = PATTERN.matcher(source); + StringBuffer sb = new StringBuffer(); + while (m.find()) { + String var = m.group(1); + String value = values.getProperty(var); + String replacement = (value != null) ? replace(value) : ""; + m.appendReplacement(sb, fixBackslashForRegex(replacement)); + } + m.appendTail(sb); + return sb.toString(); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Tokenizer.java b/src/Java/miscutil/core/util/aeonbits/owner/Tokenizer.java new file mode 100644 index 0000000000..700b453904 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Tokenizer.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +/** + * Tokenizer interface that specifies how to split a single value into tokens to be used as elements for arrays and + * collections. + * + * @author Luigi R. Viggiano + * @since 1.0.4 + */ +public interface Tokenizer { + + /** + * Splits the given string, into tokens that identify single elements. + * + * @since 1.0.4 + * @param values the string representation for the properties values + * @return the items identifying single elements to convert. + */ + String[] tokens(String values); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/TokenizerResolver.java b/src/Java/miscutil/core/util/aeonbits/owner/TokenizerResolver.java new file mode 100644 index 0000000000..78d25d7926 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/TokenizerResolver.java @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.lang.reflect.Method; + +import miscutil.core.util.aeonbits.owner.Config.Separator; +import miscutil.core.util.aeonbits.owner.Config.TokenizerClass; +import static miscutil.core.util.aeonbits.owner.Util.newInstance; +import static miscutil.core.util.aeonbits.owner.Util.unsupported; + +/** + * @author Luigi R. Viggiano + */ +final class TokenizerResolver { + + /** Don't let anyone instantiate this class */ + private TokenizerResolver() {} + + private static final Tokenizer DEFAULT_TOKENIZER = new SplitAndTrimTokenizer(","); + + static Tokenizer resolveTokenizer(Method targetMethod) { + Tokenizer methodLevelTokenizer = resolveTokenizerOnMethodLevel(targetMethod); + if (methodLevelTokenizer != null) + return methodLevelTokenizer; + + Tokenizer classLevelTokenizer = resolveTokenizerOnClassLevel(targetMethod.getDeclaringClass()); + if (classLevelTokenizer != null) + return classLevelTokenizer; + + return DEFAULT_TOKENIZER; + } + + private static Tokenizer resolveTokenizerOnClassLevel(Class<?> declaringClass) { + Separator separatorAnnotationOnClassLevel = declaringClass.getAnnotation(Separator.class); + TokenizerClass tokenizerClassAnnotationOnClassLevel = declaringClass.getAnnotation(TokenizerClass.class); + + if (separatorAnnotationOnClassLevel != null && tokenizerClassAnnotationOnClassLevel != null) + throw unsupported( + "You cannot specify @Separator and @TokenizerClass both together on class level for '%s'", + declaringClass.getCanonicalName()); + + if (separatorAnnotationOnClassLevel != null) + return new SplitAndTrimTokenizer(separatorAnnotationOnClassLevel.value()); + + if (tokenizerClassAnnotationOnClassLevel != null) + return newInstance(tokenizerClassAnnotationOnClassLevel.value()); + + return null; + } + + private static Tokenizer resolveTokenizerOnMethodLevel(Method targetMethod) { + Separator separatorAnnotationOnMethodLevel = targetMethod.getAnnotation(Separator.class); + TokenizerClass tokenizerClassAnnotationOnMethodLevel = targetMethod.getAnnotation(TokenizerClass.class); + + if (separatorAnnotationOnMethodLevel != null && tokenizerClassAnnotationOnMethodLevel != null) + throw unsupported( + "You cannot specify @Separator and @TokenizerClass both together on method level for '%s'", + targetMethod); + + if (separatorAnnotationOnMethodLevel != null) + return new SplitAndTrimTokenizer(separatorAnnotationOnMethodLevel.value()); + + if (tokenizerClassAnnotationOnMethodLevel != null) + return newInstance(tokenizerClassAnnotationOnMethodLevel.value()); + + return null; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/Util.java b/src/Java/miscutil/core/util/aeonbits/owner/Util.java new file mode 100644 index 0000000000..79dd3faa60 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/Util.java @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; +import java.lang.reflect.Method; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.jar.JarOutputStream; +import java.util.zip.ZipEntry; + +import miscutil.core.util.aeonbits.owner.Config.DisableFeature; +import miscutil.core.util.aeonbits.owner.Config.DisableableFeature; +import static java.io.File.createTempFile; +import static java.lang.String.format; +import static java.net.URLDecoder.decode; +import static java.util.Arrays.asList; + +/** + * This class contains utility methods used all over the library. + * + * @author Luigi R. Viggiano + */ +abstract class Util { + + interface TimeProvider { + long getTime(); + } + + interface SystemProvider { + String getProperty(String key); + + Map<String, String> getenv(); + + Properties getProperties(); + } + + static TimeProvider timeProvider = new TimeProvider() { + public long getTime() { + return System.currentTimeMillis(); + } + }; + + static SystemProvider system = new SystemProvider() { + public String getProperty(String key) { + return System.getProperty(key); + } + + public Map<String, String> getenv() { + return System.getenv(); + } + + public Properties getProperties() { + return System.getProperties(); + } + }; + + /** Don't let anyone instantiate this class */ + private Util() {} + + static <T> List<T> reverse(List<T> src) { + List<T> copy = new ArrayList<T>(src); + Collections.reverse(copy); + return copy; + } + + @SuppressWarnings("unchecked") + static <T> T[] reverse(T[] array) { + T[] copy = array.clone(); + Collections.reverse(asList(copy)); + return copy; + } + + static String expandUserHome(String text) { + if (text.equals("~")) + return system.getProperty("user.home"); + if (text.indexOf("~/") == 0 || text.indexOf("file:~/") == 0 || text.indexOf("jar:file:~/") == 0) + return text.replaceFirst("~/", fixBackslashForRegex(system.getProperty("user.home")) + "/"); + if (text.indexOf("~\\") == 0 || text.indexOf("file:~\\") == 0 || text.indexOf("jar:file:~\\") == 0) + return text.replaceFirst("~\\\\", fixBackslashForRegex(system.getProperty("user.home")) + "\\\\"); + return text; + } + + static String fixBackslashForRegex(String text) { + return text.replace("\\", "\\\\"); + } + + public static String fixBackslashesToSlashes(String path) { + return path.replace('\\', '/'); + } + + static <T> T ignore() { + // the ignore method does absolutely nothing, but it helps to shut up warnings by pmd and other reporting tools + // complaining about empty catch methods. + return null; + } + + static boolean isFeatureDisabled(Method method, DisableableFeature feature) { + Class<DisableFeature> annotation = DisableFeature.class; + return isFeatureDisabled(feature, method.getDeclaringClass().getAnnotation(annotation)) || + isFeatureDisabled(feature, method.getAnnotation(annotation)); + } + + private static boolean isFeatureDisabled(DisableableFeature feature, DisableFeature annotation) { + return annotation != null && asList(annotation.value()).contains(feature); + } + + static UnsupportedOperationException unsupported(Throwable cause, String msg, Object... args) { + return new UnsupportedOperationException(format(msg, args), cause); + } + + static UnsupportedOperationException unsupported(String msg, Object... args) { + return new UnsupportedOperationException(format(msg, args)); + } + + static <T> T unreachableButCompilerNeedsThis() { + throw new AssertionError("this code should never be reached"); + } + + static String asString(Object result) { + if (result == null) return null; + return String.valueOf(result); + } + + static long now() { + return timeProvider.getTime(); + } + + static File fileFromURI(URI uri) { + if ("file".equalsIgnoreCase(uri.getScheme())) { + String path = uri.getSchemeSpecificPart(); + try { + path = decode(path, "utf-8"); + return new File(path); + } catch (UnsupportedEncodingException e) { + return unreachableButCompilerNeedsThis(/* utf-8 is supported in jre libraries */); + } + } else if ("jar".equalsIgnoreCase(uri.getScheme())) { + String path = uri.getSchemeSpecificPart(); + try { + return fileFromURI(path.substring(0, path.indexOf('!'))); + } catch (URISyntaxException e) { + return ignore(/* non critical */); + } + } + return null; + } + + static File fileFromURI(String uriSpec) throws URISyntaxException { + return fileFromURI(new URI(uriSpec)); + } + + static boolean eq(Object o1, Object o2) { + return o1 == o2 || o1 != null && o1.equals(o2); + } + + static SystemProvider system() { + return system; + } + + static void save(File target, Properties p) throws IOException { + File parent = target.getParentFile(); + parent.mkdirs(); + if (isWindows()) { + store(target, p); + } else { + File tempFile = createTempFile(target.getName(), ".temp", parent); + store(tempFile, p); + rename(tempFile, target); + } + + } + + private static boolean isWindows() { + return System.getProperty("os.name").toLowerCase().indexOf("win") >= 0; + } + + static void delete(File target) { + target.delete(); + } + + private static void store(File target, Properties p) throws IOException { + OutputStream out = new FileOutputStream(target); + try { + store(out, p); + } finally { + out.close(); + } + } + + private static void store(OutputStream out, Properties p) throws IOException { + p.store(out, "saved for test"); + } + + static void saveJar(File target, String entryName, Properties props) throws IOException { + File parent = target.getParentFile(); + parent.mkdirs(); + storeJar(target, entryName, props); + } + + private static void rename(File source, File target) throws IOException { + if (!source.renameTo(target)) + throw new IOException(String.format("Failed to overwrite %s to %s", source.toString(), target.toString())); + } + + private static void storeJar(File target, String entryName, Properties props) throws IOException { + byte[] bytes = toBytes(props); + InputStream input = new ByteArrayInputStream(bytes); + JarOutputStream output = new JarOutputStream(new FileOutputStream(target)); + try { + ZipEntry entry = new ZipEntry(entryName); + output.putNextEntry(entry); + byte[] buffer = new byte[4096]; + int size; + while ((size = input.read(buffer)) != -1) + output.write(buffer, 0, size); + } finally { + input.close(); + output.close(); + } + } + + private static byte[] toBytes(Properties props) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try { + store(out, props); + return out.toByteArray(); + } finally { + out.close(); + } + } + + public static <T> T newInstance(Class<T> clazz) { + try { + return clazz.newInstance(); + } catch (Exception e) { + throw unsupported(e, + "Class '%s' cannot be instantiated; see the cause below in the stack trace", + clazz.getCanonicalName()); + } + } + + public static <T> List<T> newInstance(Class<? extends T>[] classes, List<T> result) { + for (Class<? extends T> clazz : classes) + result.add(newInstance(clazz)); + return result; + } +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/VariablesExpander.java b/src/Java/miscutil/core/util/aeonbits/owner/VariablesExpander.java new file mode 100644 index 0000000000..63bcdf07a8 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/VariablesExpander.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner; + + +import java.io.Serializable; +import java.util.Properties; + +import static miscutil.core.util.aeonbits.owner.Util.expandUserHome; + +/** + * This class is used to expand variables in the format <tt>${variable}</tt>$, using values from + * {@link System#getenv()}, {@link System#getProperties()} and the <tt>Properties</tt> object specified in the + * constructor (in inverse order; first match is accepted). + * + * @author Luigi R. Viggiano + */ +class VariablesExpander implements Serializable { + + private final StrSubstitutor substitutor; + + VariablesExpander(Properties props) { + Properties variables = new Properties(); + variables.putAll(Util.system().getenv()); + variables.putAll(Util.system().getProperties()); + variables.putAll(props); + substitutor = new StrSubstitutor(variables); + } + + String expand(String path) { + String expanded = expandUserHome(path); + return substitutor.replace(expanded); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/Event.java b/src/Java/miscutil/core/util/aeonbits/owner/event/Event.java new file mode 100644 index 0000000000..3459cd3158 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/Event.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +import java.util.EventObject; + +/** + * The root event class for all OWNER events. + * + * @author Luigi R. Viggiano + * @since 1.0.4 + */ +public class Event extends EventObject { + + /** + * Constructs a prototypical Event. + * + * @param source The object on which the Event initially occurred. + * @throws IllegalArgumentException if source is null. + */ + public Event(Object source) { + super(source); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/ReloadEvent.java b/src/Java/miscutil/core/util/aeonbits/owner/event/ReloadEvent.java new file mode 100644 index 0000000000..fcb37434cd --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/ReloadEvent.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +import java.beans.PropertyChangeEvent; +import java.util.List; +import java.util.Properties; + +import static java.util.Collections.unmodifiableList; + +/** + * A semantic event which indicates that a reload occurred. + * + * @author Luigi R. Viggiano + * @see ReloadListener + * @since 1.0.4 + */ +public class ReloadEvent extends Event { + + private final List<PropertyChangeEvent> events; + private final Properties oldProperties; + private final Properties newProperties; + + /** + * Constructs a prototypical Event. + * + * @param source The object on which the Event initially occurred. + * @param events The {@link PropertyChangeEvent change events} regarding which properties have been modified + * during the reload. + * @param oldProperties the properties before the reload. + * @param newProperties the properties after the reload. + * @throws IllegalArgumentException if source is null. + */ + public ReloadEvent(Object source, List<PropertyChangeEvent> events, Properties oldProperties, + Properties newProperties) { + super(source); + this.events = unmodifiableList(events); + this.oldProperties = new UnmodifiableProperties(oldProperties); + this.newProperties = new UnmodifiableProperties(newProperties); + } + + /** + * Returns The {@link PropertyChangeEvent change events} regarding which properties have been modified during the + * reload. + * + * @return The {@link PropertyChangeEvent change events} regarding which properties have been modified during the + * reload. + */ + public List<PropertyChangeEvent> getEvents() { + return events; + } + + /** + * Returns the properties before the reload. + * + * @return the properties before the reload. + */ + public Properties getOldProperties() { + return oldProperties; + } + + /** + * Returns the properties after the reload. + * + * @return the properties after the reload. + */ + public Properties getNewProperties() { + return newProperties; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/ReloadListener.java b/src/Java/miscutil/core/util/aeonbits/owner/event/ReloadListener.java new file mode 100644 index 0000000000..4342717927 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/ReloadListener.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +import java.util.EventListener; + +/** + * The listener interface for receiving reload events. The class that is interested in processing a reload event + * implements this interface, and the object created with that class is registered with a component, using the + * component's <code>addReloadListener</code> method. When the reload event occurs, that object's + * <code>reloadPerformed</code> method is invoked. + * + * @author Luigi R. Viggiano + * @see ReloadEvent + * @since 1.0.4 + */ +public interface ReloadListener extends EventListener { + + /** + * This method is invoked after the property are reloaded. + * When this method is invoked we can assume that the changes are effective. + * + * @param event the {@link ReloadEvent event} of property reload. + */ + void reloadPerformed(ReloadEvent event); + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackBatchException.java b/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackBatchException.java new file mode 100644 index 0000000000..90983190a2 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackBatchException.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +/** + * Indicates that whole batch of event must be rolled back. + * A batch is intended as a group of operations are executed in a row. + * For instance this happens when the whole list of properties is reloaded or cleared. + * + * @author Luigi R. Viggiano + * @since 1.0.5 + */ +public class RollbackBatchException extends RollbackException { + + public RollbackBatchException() { + super(); + } + + public RollbackBatchException(String message) { + super(message); + } + + public RollbackBatchException(Throwable cause) { + super(cause); + } + + public RollbackBatchException(String message, Throwable cause) { + super(message, cause); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackException.java b/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackException.java new file mode 100644 index 0000000000..48989a009e --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackException.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +/** + * Superclass for event rollback. + * + * @author Luigi R. Viggiano + * @since 1.0.5 + */ +public abstract class RollbackException extends Exception { + + public RollbackException() { + super(); + } + + public RollbackException(String msg) { + super(msg); + } + + public RollbackException(Throwable cause) { + super(cause); + } + + public RollbackException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackOperationException.java b/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackOperationException.java new file mode 100644 index 0000000000..5651f2410b --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/RollbackOperationException.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +/** + * Indicates that operation must be rolled back. + * + * @author Luigi R. Viggiano + * @since 1.0.5 + */ +public class RollbackOperationException extends RollbackException { + + public RollbackOperationException() { + super(); + } + + public RollbackOperationException(String message) { + super(message); + } + + public RollbackOperationException(Throwable cause) { + super(cause); + } + + public RollbackOperationException(String message, Throwable cause) { + super(message, cause); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/TransactionalPropertyChangeListener.java b/src/Java/miscutil/core/util/aeonbits/owner/event/TransactionalPropertyChangeListener.java new file mode 100644 index 0000000000..63b8787d21 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/TransactionalPropertyChangeListener.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; + +/** + * A Listener that is aware of properties changes, with transactional capability. + * + * @since 1.0.5 + * @author Luigi R. Viggiano + */ +public interface TransactionalPropertyChangeListener extends PropertyChangeListener { + + /** + * This method is invoked before the property is changed. When this method is invoked we cannot assume that the + * change is effective, since some listener can ask to roll back the change operation. + * + * @param event the {@link PropertyChangeEvent event} of property change. + * @throws RollbackOperationException when the listener wants to rollback the change on the property intercepted + * @throws RollbackBatchException when the listener wants to rollback the entire set of changes if executed in + * the batch. + */ + void beforePropertyChange(PropertyChangeEvent event) throws RollbackOperationException, RollbackBatchException; + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/TransactionalReloadListener.java b/src/Java/miscutil/core/util/aeonbits/owner/event/TransactionalReloadListener.java new file mode 100644 index 0000000000..ac376122d3 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/TransactionalReloadListener.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +/** + * A Listener that is aware of properties reloads, with transactional capability. + * + * @since 1.0.5 + * @author Luigi R. Viggiano + */ +public interface TransactionalReloadListener extends ReloadListener { + + /** + * This method is invoked before the property are reloaded. When this method is invoked we cannot assume that the + * changes are effective, since some listener can ask to roll back the change. + * + * @param event the {@link ReloadEvent event} of property reload. + * @throws RollbackBatchException when the listener wants to rollback the entire reload. + */ + void beforeReload(ReloadEvent event) throws RollbackBatchException; + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/UnmodifiableProperties.java b/src/Java/miscutil/core/util/aeonbits/owner/event/UnmodifiableProperties.java new file mode 100644 index 0000000000..7fb08bb26b --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/UnmodifiableProperties.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.event; + +import java.util.Collection; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Properties; +import java.util.Set; + +import static java.util.Collections.unmodifiableCollection; +import static java.util.Collections.unmodifiableSet; + +/** + * @author Luigi R. Viggiano + */ +class UnmodifiableProperties extends Properties { + + public UnmodifiableProperties(Properties properties) { + fill(properties); + } + + private void fill(Map<?, ?> t) { + for (Map.Entry<?, ?> e : t.entrySet()) + super.put(e.getKey(), e.getValue()); + } + + @Override + public synchronized Object put(Object key, Object value) { + throw new UnsupportedOperationException(); + } + + @Override + public synchronized Object remove(Object key) { + throw new UnsupportedOperationException(); + } + + @Override + public synchronized void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public Set<Object> keySet() { + return unmodifiableSet(super.keySet()); + } + + @Override + public Set<Entry<Object, Object>> entrySet() { + return unmodifiableSet(super.entrySet()); + } + + @Override + public Collection<Object> values() { + return unmodifiableCollection(super.values()); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/event/package-info.java b/src/Java/miscutil/core/util/aeonbits/owner/event/package-info.java new file mode 100644 index 0000000000..2763d038a9 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/event/package-info.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +/** + * Provides interfaces and classes for dealing with different types of events fired by OWNER components. + * + * See the {@link miscutil.core.util.aeonbits.owner.event.Event} class. Events are fired by event sources. + * An event listener registers with an event source to receive notifications about the events of a + * particular type. This package defines events and event listeners, as well as event listener adapters, + * which are convenience classes to make easier the process of writing event listeners. + */ +package miscutil.core.util.aeonbits.owner.event; diff --git a/src/Java/miscutil/core/util/aeonbits/owner/loaders/Loader.java b/src/Java/miscutil/core/util/aeonbits/owner/loaders/Loader.java new file mode 100644 index 0000000000..7a42d9b5a3 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/loaders/Loader.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.loaders; + +import java.io.IOException; +import java.io.Serializable; +import java.net.URI; +import java.util.Properties; + +/** + * Defines the interface of a generic Properties loader. + * + * @author Luigi R. Viggiano + * @since 1.0.5 + */ +public interface Loader extends Serializable { + + /** + * Indicates wether this Loader does accept the URL, guessing the content type from it. + * + * @since 1.1.0 + * @param uri the URI + * @return true, if the loader is able to handle the content of the URI. + */ + boolean accept(URI uri); + + /** + * Loads the given {@link URI uri} into the given {@link Properties result} + * + * @since 1.1.0 + * @param result the resulting properties where to load the {@link URI uri} + * @param uri the {@link URI} from where to load the properties. + * @throws java.io.IOException if there is some I/O error during the load. + */ + void load(Properties result, URI uri) throws IOException; + + /** + * Returns the default URI specification for a given url resource, that can be handled by this loader. + * + * @param uriPrefix the prefix identifying the url resource. + * @return the default URI specification for a given uri resource, that can be handled by this loader. + */ + String defaultSpecFor(String uriPrefix); +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/loaders/PropertiesLoader.java b/src/Java/miscutil/core/util/aeonbits/owner/loaders/PropertiesLoader.java new file mode 100644 index 0000000000..6eeea0439a --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/loaders/PropertiesLoader.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.loaders; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.util.Properties; + +/** + * A {@link Loader loader} able to read properties from standard Java properties files. + * + * @since 1.0.5 + * @author Luigi R. Viggiano + */ +public class PropertiesLoader implements Loader { + + private static final long serialVersionUID = -1781643040589572341L; + private static final String DEFAULT_ENCODING = "UTF-8"; + + public boolean accept(URI uri) { + try { + uri.toURL(); + return true; + } catch (MalformedURLException ex) { + return false; + } + } + + public void load(Properties result, URI uri) throws IOException { + URL url = uri.toURL(); + InputStream input = url.openStream(); + try { + load(result, input); + } finally { + input.close(); + } + } + + void load(Properties result, InputStream input) throws IOException { + result.load(new InputStreamReader(input, DEFAULT_ENCODING)); + } + + public String defaultSpecFor(String uriPrefix) { + return uriPrefix + ".properties"; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/loaders/XMLLoader.java b/src/Java/miscutil/core/util/aeonbits/owner/loaders/XMLLoader.java new file mode 100644 index 0000000000..ac8b8bedcd --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/loaders/XMLLoader.java @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.loaders; + +import org.xml.sax.Attributes; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.SAXParseException; +import org.xml.sax.ext.DefaultHandler2; + +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; +import java.io.IOException; +import java.io.InputStream; +import java.io.StringReader; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.util.Properties; +import java.util.Stack; + +/** + * A {@link Loader loader} able to read properties from standard XML Java properties files, as well as user defined + * XML properties files. + * + * @since 1.0.5 + * @author Luigi R. Viggiano + */ +public class XMLLoader implements Loader { + + private static final long serialVersionUID = -894351666332018767L; + private transient volatile SAXParserFactory factory = null; + + private SAXParserFactory factory() { + if (factory == null) { + synchronized (this) { + if (factory == null) { + factory = SAXParserFactory.newInstance(); + factory.setValidating(true); + factory.setNamespaceAware(true); + } + } + } + return factory; + } + + static class XmlToPropsHandler extends DefaultHandler2 { + + private static final String PROPS_DTD_URI = + "http://java.sun.com/dtd/properties.dtd"; + + private static final String PROPS_DTD = + "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + + "<!-- DTD for properties -->" + + "<!ELEMENT properties ( comment?, entry* ) >" + + "<!ATTLIST properties version CDATA #FIXED \"1.0\">" + + "<!ELEMENT comment (#PCDATA) >" + + "<!ELEMENT entry (#PCDATA) >" + + "<!ATTLIST entry key CDATA #REQUIRED>"; + + private boolean isJavaPropertiesFormat = false; + private final Properties props; + private final Stack<String> paths = new Stack<String>(); + private final Stack<StringBuilder> value = new Stack<StringBuilder>(); + + @Override + public InputSource resolveEntity(String name, String publicId, String baseURI, + String systemId) throws SAXException, IOException { + InputSource inputSource = null; + if (systemId.equals(PROPS_DTD_URI)) { + isJavaPropertiesFormat = true; + inputSource = new InputSource(new StringReader(PROPS_DTD)); + inputSource.setSystemId(PROPS_DTD_URI); + } + return inputSource; + } + + public XmlToPropsHandler(Properties props) { + this.props = props; + } + + @Override + public void startElement(String uri, String localName, String qName, + Attributes attributes) throws SAXException { + value.push(new StringBuilder()); + + if (isJavaPropertiesFormat) { + if ("entry".equals(qName)) + paths.push(attributes.getValue("key")); + else + paths.push(qName); + } else { + String path = (paths.size() == 0) ? qName : paths.peek() + "." + qName; + paths.push(path); + for (int i = 0; i < attributes.getLength(); i++) { + String attrName = attributes.getQName(i); + String attrValue = attributes.getValue(i); + props.setProperty(path + "." + attrName, attrValue); + } + } + } + + @Override + public void characters(char[] ch, int start, int length) throws SAXException { + value.peek().append(new String(ch, start, length)); + } + + @Override + public void endElement(String uri, String localName, String qName) throws SAXException { + String key = paths.peek(); + String propertyValue = this.value.peek().toString().trim(); + if (!propertyValue.isEmpty() && + !(isJavaPropertiesFormat && "comment".equals(key))) + props.setProperty(key, propertyValue); + value.pop(); + paths.pop(); + } + + @Override + public void error(SAXParseException e) throws SAXException { + if (isJavaPropertiesFormat) + throw e; + } + } + + public boolean accept(URI uri) { + try { + URL url = uri.toURL(); + return url.getFile().toLowerCase().endsWith(".xml"); + } catch (MalformedURLException ex) { + return false; + } + } + + public void load(Properties result, URI uri) throws IOException { + InputStream input = uri.toURL().openStream(); + try { + SAXParser parser = factory().newSAXParser(); + XmlToPropsHandler h = new XmlToPropsHandler(result); + parser.setProperty("http://xml.org/sax/properties/lexical-handler", h); + parser.parse(input, h); + } catch (ParserConfigurationException e) { + throw new IllegalArgumentException(e); + } catch (SAXException e) { + throw new IOException(e); + } finally { + input.close(); + } + } + + public String defaultSpecFor(String urlPrefix) { + return urlPrefix + ".xml"; + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/loaders/package-info.java b/src/Java/miscutil/core/util/aeonbits/owner/loaders/package-info.java new file mode 100644 index 0000000000..eefaa5b7cc --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/loaders/package-info.java @@ -0,0 +1,12 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +/** + * Provides interfaces and classes to allow OWNER to load properties from several file formats. + */ +package miscutil.core.util.aeonbits.owner.loaders; diff --git a/src/Java/miscutil/core/util/aeonbits/owner/package-info.java b/src/Java/miscutil/core/util/aeonbits/owner/package-info.java new file mode 100644 index 0000000000..199b3dd4bb --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/package-info.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +/** + * <p> + * The goal of OWNER API is to minimize the code required to handle application configuration through Java properties + * files. + * </p> + * + * <p> + * The approach used by OWNER APIs, is to define a Java interface associated to a properties file. + * </p> + * + * Suppose your properties file is defined as ServerConfig.properties: + * + * <pre> + * port=80 + * hostname=foobar.com + * maxThreads=100 + * </pre> + * + * To access this property you need to define a convenient Java interface in ServerConfig.java: + * + * <pre> + * public interface ServerConfig extends Config { + * int port(); + * String hostname(); + * + * @DefaultValue("42"); + * int maxThreads(); + * } + * </pre> + * + * <p> + * We'll call this interface the Properties Mapping Interface or just Mapping Interface since its goal is to map + * Properties into a an easy to use piece of code. + * </p> + * + * <p> + * Owner has a lot of features and its behavior is fully customizable to your needs. + * </p> + * <p> + * Have a look at the full documentation from the <a href="http://owner.aeonbits.org/" target="_top">OWNER website</a>. + * </p> + */ +package miscutil.core.util.aeonbits.owner; diff --git a/src/Java/miscutil/core/util/aeonbits/owner/util/Collections.java b/src/Java/miscutil/core/util/aeonbits/owner/util/Collections.java new file mode 100644 index 0000000000..b31611bb43 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/util/Collections.java @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.util; + +import java.io.Serializable; +import java.util.AbstractMap; +import java.util.AbstractMap.SimpleEntry; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +import static java.util.Arrays.asList; + +/** + * Utility class to create a maps, lists and sets + * <p> Examples of usage: </p> + * <pre> + * import static org.aeonbits.owner.util.Collections.map; + * import static org.aeonbits.owner.util.Collections.entry; + * import static org.aeonbits.owner.util.Collections.set; + * import static org.aeonbits.owner.util.Collections.list; + * + * Map<String, String> myMap = map("foo", "bar"); + * Map<String, String> myMap2 = map(entry("foo", "bar"), entry("baz", "qux"); + * Set<String> mySet = set("foo", "bar", "baz", "qux"); + * List<String> myList = list("foo", "bar", "baz", "qux"); + * </pre> + * + * @author Luigi R. Viggiano + * @since 1.0.6 + */ +public abstract class Collections { + + // Suppresses default constructor, ensuring non-instantiability. + private Collections() {} + + private static final class EntryMap<K, V> extends AbstractMap<K, V> implements Serializable { + private static final long serialVersionUID = -789853606407653214L; + private final Set<Entry<? extends K, ? extends V>> entries; + + private EntryMap(Entry<? extends K, ? extends V>... entries) { + this.entries = set(entries); + } + + @SuppressWarnings("unchecked") + @Override + public Set<Entry<K, V>> entrySet() { + return (Set) entries; + } + } + + public static <K, V> Entry<K, V> entry(K key, V value) { + return new SimpleEntry<K, V>(key, value); + } + + @SuppressWarnings("unchecked") + public static <K, V> Map<K, V> map(K key, V value) { + return map(entry(key, value)); + } + + public static <K, V> Map<K, V> map(Map.Entry<? extends K, ? extends V>... entries) { + return new EntryMap<K, V>(entries); + } + + public static <E> Set<E> set(E... elements) { + return new LinkedHashSet<E>(list(elements)); + } + + public static <E> List<E> list(E... elements) { + return asList(elements); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/util/Reflection.java b/src/Java/miscutil/core/util/aeonbits/owner/util/Reflection.java new file mode 100644 index 0000000000..1ba3902b45 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/util/Reflection.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +package miscutil.core.util.aeonbits.owner.util; + +import java.lang.reflect.Method; + +/** + * @author Luigi R. Viggiano + */ +public final class Reflection { + + // Suppresses default LOOKUP_CONSTRUCTOR, ensuring non-instantiability. + private Reflection() { + } + + public static boolean isClassAvailable(String className) { + try { + Class.forName(className); + return true; + } catch (ClassNotFoundException e) { + return false; + } + } + + interface Java8Support { + boolean isDefault(Method method); + + Object invokeDefaultMethod(Object proxy, Method method, Object[] args) throws Throwable; + } + + private static final Java8Support JAVA_8_SUPPORT = getJava8Support(); + + private static Java8Support getJava8Support() { + try { + return (Java8Support) Class.forName("org.aeonbits.owner.util.Java8SupportImpl").newInstance(); + } catch (Exception e) { + return java8NotSupported(); + } + } + + private static Java8Support java8NotSupported() { + return new Java8Support() { + public boolean isDefault(Method method) { + return false; + } + + public Object invokeDefaultMethod(Object proxy, Method method, Object[] args) throws Throwable { + return null; + } + }; + } + + + public static boolean isDefault(Method method) { + return JAVA_8_SUPPORT.isDefault(method); + } + + public static Object invokeDefaultMethod(Object proxy, Method method, Object[] args) throws Throwable { + return JAVA_8_SUPPORT.invokeDefaultMethod(proxy, method, args); + } + +} diff --git a/src/Java/miscutil/core/util/aeonbits/owner/util/package-info.java b/src/Java/miscutil/core/util/aeonbits/owner/util/package-info.java new file mode 100644 index 0000000000..3707866c16 --- /dev/null +++ b/src/Java/miscutil/core/util/aeonbits/owner/util/package-info.java @@ -0,0 +1,12 @@ +/* + * Copyright (c) 2012-2015, Luigi R. Viggiano + * All rights reserved. + * + * This software is distributable under the BSD license. + * See the terms of the BSD license in the documentation provided with this software. + */ + +/** + * Provides utility interfaces and classes. + */ +package miscutil.core.util.aeonbits.owner.util; diff --git a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java index e0c1376d45..edc2981a53 100644 --- a/src/Java/miscutil/core/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java +++ b/src/Java/miscutil/core/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityIndustrialCentrifuge.java @@ -13,21 +13,19 @@ import gregtech.api.util.GT_Utility; import java.util.ArrayList; import java.util.Arrays; -import java.util.List; import miscutil.core.block.ModBlocks; import miscutil.core.lib.CORE; import miscutil.core.util.Utils; import miscutil.core.xmod.gregtech.api.gui.GUI_MultiMachine; import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase; +import miscutil.core.xmod.gregtech.api.util.GregtechRecipe; import net.minecraft.block.Block; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.item.ItemStack; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; -import org.apache.commons.lang3.ArrayUtils; - public class GregtechMetaTileEntityIndustrialCentrifuge extends GregtechMeta_MultiBlockBase { private static boolean controller; @@ -104,129 +102,67 @@ extends GregtechMeta_MultiBlockBase { @Override public boolean checkRecipe(ItemStack aStack) { - long tVoltage = getMaxInputVoltage(); - byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); - - GT_Recipe.GT_Recipe_Map map = getRecipeMap(); - for (int i = 0; i < tInputList.size() - 1; i++) { - for (int j = i + 1; j < tInputList.size(); j++) { - if (GT_Utility.areStacksEqual((ItemStack) tInputList.get(i), (ItemStack) tInputList.get(j))) { - if (((ItemStack) tInputList.get(i)).stackSize >= ((ItemStack) tInputList.get(j)).stackSize) { - tInputList.remove(j--); - } else { - tInputList.remove(i--); - break; - } - } - } - } - ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2); - - ArrayList<FluidStack> tFluidList = getStoredFluids(); - for (int i = 0; i < tFluidList.size() - 1; i++) { - for (int j = i + 1; j < tFluidList.size(); j++) { - if (GT_Utility.areFluidsEqual((FluidStack) tFluidList.get(i), (FluidStack) tFluidList.get(j))) { - if (((FluidStack) tFluidList.get(i)).amount >= ((FluidStack) tFluidList.get(j)).amount) { - tFluidList.remove(j--); - } else { - tFluidList.remove(i--); - break; - } - } - } - } - FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1); - if (tInputList.size() > 0 || tFluids.length > 0) { - GT_Recipe tRecipe = map.findRecipe(getBaseMetaTileEntity(), mLastRecipe, false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs); - if (tRecipe != null) { - if (tRecipe.mFluidInputs != null) { + ArrayList<ItemStack> tInputList = getStoredInputs(); + for (int i = 0; i < tInputList.size() - 1; i++) { + for (int j = i + 1; j < tInputList.size(); j++) { + if (GT_Utility.areStacksEqual((ItemStack) tInputList.get(i), (ItemStack) tInputList.get(j))) { + if (((ItemStack) tInputList.get(i)).stackSize >= ((ItemStack) tInputList.get(j)).stackSize) { + tInputList.remove(j--); + } else { + tInputList.remove(i--); + break; + } + } + } + } + ItemStack[] tInputs = (ItemStack[]) Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2); - } - mLastRecipe = tRecipe; - this.mEUt = 0; - this.mOutputItems = null; - this.mOutputFluids = null; - int machines = Math.min(16, mInventory[1].stackSize); - int i = 0; - for (; i < machines; i++) { - if (!tRecipe.isRecipeInputEqual(true, tFluids, tInputs)) { - if (i == 0) { - Utils.LOG_INFO("false 1"); - return false; - } - break; - } - } - this.mMaxProgresstime = tRecipe.mDuration; - this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000); - this.mEfficiencyIncrease = 10000; - if (tRecipe.mEUt <= 16) { - this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1)); - this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1)); - } else { - this.mEUt = tRecipe.mEUt; - this.mMaxProgresstime = tRecipe.mDuration; - while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) { - this.mEUt *= 4; - this.mMaxProgresstime /= 4; - } - } - this.mEUt *= i; - if (this.mEUt > 0) { - this.mEUt = (-this.mEUt); - } - ItemStack[] tOut = new ItemStack[tRecipe.mOutputs.length]; - for (int h = 0; h < tRecipe.mOutputs.length; h++) { - tOut[h] = tRecipe.getOutput(h).copy(); - tOut[h].stackSize = 0; - } - FluidStack tFOut = null; - if (tRecipe.getFluidOutput(0) != null) tFOut = tRecipe.getFluidOutput(0).copy(); - for (int f = 0; f < tOut.length; f++) { - if (tRecipe.mOutputs[f] != null && tOut[f] != null) { - for (int g = 0; g < i; g++) { - if (getBaseMetaTileEntity().getRandomNumber(10000) < tRecipe.getOutputChance(f)) - tOut[f].stackSize += tRecipe.mOutputs[f].stackSize; - } - } - } - if (tFOut != null) { - int tSize = tFOut.amount; - tFOut.amount = tSize * i; - } - this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); - List<ItemStack> overStacks = new ArrayList<ItemStack>(); - for (int f = 0; f < tOut.length; f++) { - if (tOut[f].getMaxStackSize() < tOut[f].stackSize) { - while (tOut[f].getMaxStackSize() < tOut[f].stackSize) { - ItemStack tmp = tOut[f].copy(); - tmp.stackSize = tmp.getMaxStackSize(); - tOut[f].stackSize = tOut[f].stackSize - tOut[f].getMaxStackSize(); - overStacks.add(tmp); - } - } - } - if (overStacks.size() > 0) { - ItemStack[] tmp = new ItemStack[overStacks.size()]; - tmp = overStacks.toArray(tmp); - tOut = ArrayUtils.addAll(tOut, tmp); - } - List<ItemStack> tSList = new ArrayList<ItemStack>(); - for (ItemStack tS : tOut) { - if (tS.stackSize > 0) tSList.add(tS); - } - tOut = tSList.toArray(new ItemStack[tSList.size()]); - this.mOutputItems = tOut; - this.mOutputFluids = new FluidStack[]{tFOut}; - updateSlots(); - //recipesComplete++; - Utils.LOG_INFO("true 1"); - return true; - } - } - Utils.LOG_INFO("false 2"); - return false; - } + ArrayList<FluidStack> tFluidList = getStoredFluids(); + for (int i = 0; i < tFluidList.size() - 1; i++) { + for (int j = i + 1; j < tFluidList.size(); j++) { + if (GT_Utility.areFluidsEqual((FluidStack) tFluidList.get(i), (FluidStack) tFluidList.get(j))) { + if (((FluidStack) tFluidList.get(i)).amount >= ((FluidStack) tFluidList.get(j)).amount) { + tFluidList.remove(j--); + } else { + tFluidList.remove(i--); + break; + } + } + } + } + FluidStack[] tFluids = (FluidStack[]) Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tInputList.size()]), 0, 1); + if (tInputList.size() > 0) { + long tVoltage = getMaxInputVoltage(); + byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); + GT_Recipe tRecipe = GregtechRecipe.Gregtech_Recipe_Map.sCokeOvenRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], tFluids, tInputs); + if ((tRecipe != null) && (3 >= tRecipe.mSpecialValue) && (tRecipe.isRecipeInputEqual(true, tFluids, tInputs))) { + this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000); + this.mEfficiencyIncrease = 10000; + if (tRecipe.mEUt <= 16) { + this.mEUt = (tRecipe.mEUt * (1 << tTier - 1) * (1 << tTier - 1)); + this.mMaxProgresstime = (tRecipe.mDuration / (1 << tTier - 1)); + } else { + this.mEUt = tRecipe.mEUt; + this.mMaxProgresstime = tRecipe.mDuration; + while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) { + this.mEUt *= 4; + this.mMaxProgresstime /= 2; + } + } + if (this.mEUt > 0) { + this.mEUt = (-this.mEUt); + } + this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); + this.mOutputItems = new ItemStack[]{tRecipe.getOutput(0)}; + this.mOutputFluids = new FluidStack[]{tRecipe.getFluidOutput(0)}; + updateSlots(); + Utils.LOG_INFO("Centrifuge: True"); + return true; + } + } + Utils.LOG_INFO("Centrifuge: False"); + return false; + } @SuppressWarnings("static-method") public Block getCasingBlock() { |