jomu/shared
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases 7 Activity

first commit

Browse Source
This commit is contained in:
jomu
2013-02-06 22:06:43 +00:00
parent 1a6d3e4c41
commit aef92c311d
84 changed files with 5334 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
configuration/nb-configuration.xml Normal file
View File

@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<project-shared-configuration>
<!--
This file contains additional configuration written by modules in the NetBeans IDE.
The configuration is intended to be shared among all the users of project and
therefore it is assumed to be part of version control checkout.
Without this configuration present, some functionality in the IDE may be limited or fail altogether.
-->
<properties xmlns="http://www.netbeans.org/ns/maven-properties-data/1">
<!--
Properties that influence various parts of the IDE, especially code formatting and the like.
You can copy and paste the single properties, into the pom.xml file and the IDE will pick them up.
That way multiple projects can share the same settings (useful for formatting rules for example).
Any value defined here will override the pom.xml file value but is only applicable to the current project.
-->
<netbeans.checkstyle.format>true</netbeans.checkstyle.format>
</properties>
</project-shared-configuration>

44
configuration/pom.xml Normal file
View File

@ -0,0 +1,44 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>de.muehlencord.shared</groupId>
<artifactId>shared-configuration</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<parent>
<artifactId>shared</artifactId>
<groupId>de.muehlencord</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<name>shared-configuration</name>
<url>http://maven.apache.org</url>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
</plugins>
</build>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

51
configuration/src/main/java/de/muehlencord/shared/configuration/BooleanParameter.java Normal file
View File

@ -0,0 +1,51 @@
package de.muehlencord.shared.configuration;
import de.muehlencord.shared.configuration.converter.BooleanStringConverter;
/**
* A Boolean parameter
* @author joern@muehlencord.de
*/
public class BooleanParameter extends Parameter<Boolean> {
/**
* creates a new mandatory parameter object using default string converter
*
* @param name the name of the parameter
*/
public BooleanParameter(String name) {
super(name, new BooleanStringConverter(), true);
}
/**
* creates a new mandatory parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
*/
public BooleanParameter(String name, StringConverter<Boolean> converter) {
super(name, converter, true);
}
/**
* creates a new parameter object using default string converter
*
* @param name the name of the parameter
* @param mandatory detremines if this is a mandatory parameter or not
*/
public BooleanParameter(String name, boolean mandatory) {
super(name, new BooleanStringConverter(), mandatory);
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param mandatory detremines if this is a mandatory parameter or not
*/
public BooleanParameter(String name, StringConverter<Boolean> converter, boolean mandatory) {
super(name, converter, mandatory);
}
}

79
configuration/src/main/java/de/muehlencord/shared/configuration/Configuration.java Normal file
View File

@ -0,0 +1,79 @@
package de.muehlencord.shared.configuration;
/**
*
* @author jomu
*/
public interface Configuration<T, V extends T> {
/**
* adds a new parameter to the configuration
*
* @param p the parameter to add
* @throws ConfigurationException if the parameter cannot be added
*/
public void addParameter(Parameter<T> p) throws ConfigurationException;
/**
* sets the value of the given parameter
*
* @param p parameter to set
* @param value value to set
* @throws ConfigurationException if the parameter is not defined
*/
public void setParameterValue(Parameter<T> p, V value) throws ConfigurationException;
/**
* sets the value of parameter with given name
*
* @param parameterName parameter to set
* @param value value to set
* @throws ConfigurationException if the parameter is not defined
*/
public void setParameterValue(String parameterName, V value) throws ConfigurationException;
/**
* sets the value of the given parameter
*
* @param p parameter to set
* @param value value to set
* @throws ConfigurationException if the parameter is not defined
*/
public void setParameterValueByString(Parameter<T> p, String value) throws ConfigurationException;
/**
* sets the value of the given parameter
*
* @param parameterName the name of the parameter to set the value for
* @param stringValue the value of the parameter as string
* @throws ConfigurationException if the parameter cannot be found or set
*/
public void setParameterValueByString(String parameterName, String stringValue) throws ConfigurationException;
/**
* returns the value of the given parameter
*
* @param p the parameter to return the value for
* @return the value of the given parameter; null if not set
*
* @throws ConfigurationException if the parameter is not defined or if the value is not set
*/
public V getParameterValue(Parameter<T> p) throws ConfigurationException;
/**
* returns the value of the given parameter
*
* @param parameterName the name of the parameter to return the value for
* @return the value of the given parameter; null if not set
*
* @throws ConfigurationException if the parameter is not defined or if the value is not set
*/
public V getParameterValue(String parameterName) throws ConfigurationException;
/**
* validates the configuration
*
* @throws ConfigurationException if the configuration is invalid
*/
public void validateConfiguration() throws ConfigurationException;
}

36
configuration/src/main/java/de/muehlencord/shared/configuration/ConfigurationException.java Normal file
View File

@ -0,0 +1,36 @@
package de.muehlencord.shared.configuration;
/**
*
* @author jomu
*/
public class ConfigurationException extends Exception {
/**
* Creates a new instance of
* <code>ParameterException</code> without detail message.
*/
public ConfigurationException() {
}
/**
* Constructs an instance of
* <code>ParameterException</code> with the specified detail message.
*
* @param msg the detail message.
*/
public ConfigurationException(String msg) {
super(msg);
}
/**
* Constructs an instance of
* <code>ParameterException</code> with the specified detail message.
*
* @param msg the detail message.
* @param th the root cause
*/
public ConfigurationException(String msg, Throwable th) {
super(msg, th);
}
}

36
configuration/src/main/java/de/muehlencord/shared/configuration/ConverterException.java Normal file
View File

@ -0,0 +1,36 @@
package de.muehlencord.shared.configuration;
/**
*
* @author jomu
*/
public class ConverterException extends Exception {
/**
* Creates a new instance of
* <code>ConverterException</code> without detail message.
*/
public ConverterException() {
}
/**
* Constructs an instance of
* <code>ConverterException</code> with the specified detail message.
*
* @param msg the detail message.
*/
public ConverterException(String msg) {
super(msg);
}
/**
* Constructs an instance of
* <code>ConverterException</code> with the specified detail message.
*
* @param msg the detail message.
* @param th the causing exception
*/
public ConverterException(String msg, Throwable th) {
super(msg, th);
}
}

52
configuration/src/main/java/de/muehlencord/shared/configuration/DateParameter.java Normal file
View File

@ -0,0 +1,52 @@
package de.muehlencord.shared.configuration;
import de.muehlencord.shared.configuration.converter.DateStringConverter;
import java.util.Date;
/**
* A Date parameter
* @author joern@muehlencord.de
*/
public class DateParameter extends Parameter<Date> {
/**
* creates a new mandatory parameter object using default string converter
*
* @param name the name of the parameter
*/
public DateParameter(String name) {
super(name, new DateStringConverter(), true);
}
/**
* creates a new mandatory parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
*/
public DateParameter(String name, StringConverter<Date> converter) {
super(name, converter, true);
}
/**
* creates a new parameter object using default string converter
*
* @param name the name of the parameter
* @param mandatory detremines if this is a mandatory parameter or not
*/
public DateParameter(String name, boolean mandatory) {
super(name, new DateStringConverter(), mandatory);
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param mandatory detremines if this is a mandatory parameter or not
*/
public DateParameter(String name, StringConverter<Date> converter, boolean mandatory) {
super(name, converter, mandatory);
}
}

224
configuration/src/main/java/de/muehlencord/shared/configuration/DefaultConfiguration.java Normal file
View File

@ -0,0 +1,224 @@
package de.muehlencord.shared.configuration;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
*
* @param <T> the type of the parameter
* @param <V> the value of the parameter - must be the same class as the type class of the parameter
* @author joern@muehlencord.de
*/
public class DefaultConfiguration<T, V extends T> implements Configuration<T, V> {
/**
* the parameter map
*/
private Map<Parameter<T>, V> parameterMap;
/** mapping from name to parameter */
private Map<String, Parameter<T>> parameterNameMap;
/**
* creates a new instance of a configuration
*/
public DefaultConfiguration() {
parameterMap = new HashMap<Parameter<T>, V>();
parameterNameMap = new HashMap<String, Parameter<T>>();
}
/**
* returns the map of parameters and values
*
* @return the map of parameters and values
*/
protected Map<Parameter<T>, V> getParameterMap() {
return parameterMap;
}
/**
* adds a new parameter to the configuration
*
* @param p the parameter to add
* @throws ConfigurationException if the parameter cannot be added
*/
@Override
public void addParameter(Parameter p) throws ConfigurationException {
if (parameterMap.containsKey(p)) {
throw new ConfigurationException("Parameter named " + p.getName() + " already defined");
} else {
parameterMap.put(p, null);
parameterNameMap.put(p.getName(), p);
}
}
/**
* validates the configuration
*
* @throws ConfigurationException if the configuration is invalid
*/
@Override
public void validateConfiguration() throws ConfigurationException {
List<Parameter> missingMandatoryParameters = new LinkedList<Parameter>();
for (Parameter p : parameterMap.keySet()) {
if ((!validateParameter(p)) && (!missingMandatoryParameters.contains(p))) {
missingMandatoryParameters.add(p);
}
}
if (!missingMandatoryParameters.isEmpty()) {
throw new ConfigurationException("Configuration invalid, mandatory parameters missing: " + missingMandatoryParameters.toString());
}
}
/**
* sets the value of the given parameter
*
* @param p parameter to set
* @param value value to set
* @throws ConfigurationException if the parameter is not defined
*/
@Override
public void setParameterValue(Parameter<T> p, V value) throws ConfigurationException {
if (parameterMap.containsKey(p)) {
parameterMap.put(p, value);
} else {
throw new ConfigurationException("Parameter " + p.getName() + " not defined");
}
}
/**
* sets the value of parameter with given name
*
* @param parameterName parameter to set
* @param value value to set
* @throws ConfigurationException if the parameter is not defined
*/
@Override
public void setParameterValue(String parameterName, V value) throws ConfigurationException {
if (parameterNameMap.containsKey(parameterName)) {
Parameter<T> p = parameterNameMap.get(parameterName);
parameterMap.put(p, value);
} else {
throw new ConfigurationException("Parameter " + parameterName + " not defined");
}
}
/**
* sets the value of the given parameter
*
* @param p parameter to set
* @param stringValue value to set
* @throws ConfigurationException if the parameter is not defined
*/
@Override
public void setParameterValueByString(Parameter<T> p, String stringValue) throws ConfigurationException {
if (parameterMap.containsKey(p)) {
try {
V value = p.getStringConverter().fromString(stringValue);
parameterMap.put(p, value);
} catch (ConverterException ex) {
throw new ConfigurationException("Error while setting parameter value for parameter " + p.getName() + ". Reason:" + ex.getMessage(), ex);
}
} else {
throw new ConfigurationException("Parameter " + p.getName() + " not defined");
}
}
/**
* sets the value of the given parameter
*
* @param parameterName name of parameter to set the value for
* @param stringValue value to set
* @throws ConfigurationException if the parameter is not defined
*/
@Override
public void setParameterValueByString(String parameterName, String stringValue) throws ConfigurationException {
if (parameterNameMap.containsKey(parameterName)) {
Parameter<T> p = parameterNameMap.get(parameterName);
if (parameterMap.containsKey(p)) {
try {
V value = p.getStringConverter().fromString(stringValue);
parameterMap.put(p, value);
} catch (ConverterException ex) {
throw new ConfigurationException("Error while setting parameter value for parameter " + p.getName() + ". Reason:" + ex.getMessage(), ex);
}
} else {
throw new ConfigurationException("Parameter " + p.getName() + " not defined");
}
} else {
throw new ConfigurationException("Parameter with name " + parameterName + " not found in configuration");
}
}
/**
* returns the value of the given parameter
*
* @param p the parameter to return the value for
* @return the value of the given parameter
*
* @throws ConfigurationException if the value cannot be determined
*/
@Override
public V getParameterValue(Parameter<T> p) throws ConfigurationException {
if (parameterMap.containsKey(p)) {
return parameterMap.get(p);
} else {
throw new ConfigurationException("Parameter " + p.getName() + " not defined");
}
}
/**
* returns the value of the given parameter
*
* @param parameterName the name of the parameter to return the value for
* @return the value of the given parameter; null if not set
*
* @throws ConfigurationException if the parameter is not defined or if the value is not set
*/
@Override
public V getParameterValue(String parameterName) throws ConfigurationException {
if (parameterNameMap.containsKey(parameterName)) {
Parameter<T> p = parameterNameMap.get(parameterName);
return getParameterValue(p);
} else {
throw new ConfigurationException("Parameter " + parameterName + " not defined");
}
}
/**
* validates a parameter. Returns true, if the parameter setup is valid; false otherwise
*
* @param p the parameter to validate
* @return true, if the parameter is valid (mandatory parameter set, depending parameters set); false otherwise
*
* @throws ConfigurationException if a check fails
*/
private boolean validateParameter(Parameter<T> p) throws ConfigurationException {
// check if parameter is mandatory and available
if ((p.isMandatory()) && (parameterMap.get(p) == null)) {
return false;
}
// check if parameter has required parameters and if these are set
V parameterValue = getParameterValue(p);
if (parameterValue != null) {
for (Parameter rp : p.getRequiredParameter()) {
if (getParameterValue(rp) == null) {
return false;
}
}
}
// check if parameter has uses value list -if yes ensure only valid value is selected
if (!p.isValid(parameterValue)) {
throw new ConfigurationException("Value for paramter " + p.getName() + " is invalid.");
}
return true;
}
}

51
configuration/src/main/java/de/muehlencord/shared/configuration/IntegerParameter.java Normal file
View File

@ -0,0 +1,51 @@
package de.muehlencord.shared.configuration;
import de.muehlencord.shared.configuration.converter.IntegerStringConverter;
/**
* A Integer parameter
*
* @author joern@muehlencord.de
*/
public class IntegerParameter extends Parameter<Integer> {
/**
* creates a new mandatory parameter object using default string converter
*
* @param name the name of the parameter
*/
public IntegerParameter(String name) {
super(name, new IntegerStringConverter(), true);
}
/**
* creates a new mandatory parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
*/
public IntegerParameter(String name, StringConverter<Integer> converter) {
super(name, converter, true);
}
/**
* creates a new parameter object using default string converter
*
* @param name the name of the parameter
* @param mandatory detremines if this is a mandatory parameter or not
*/
public IntegerParameter(String name, boolean mandatory) {
super(name, new IntegerStringConverter(), mandatory);
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param mandatory detremines if this is a mandatory parameter or not
*/
public IntegerParameter(String name, StringConverter<Integer> converter, boolean mandatory) {
super(name, converter, mandatory);
}
}

168
configuration/src/main/java/de/muehlencord/shared/configuration/Parameter.java Normal file
View File

@ -0,0 +1,168 @@
package de.muehlencord.shared.configuration;
import java.util.LinkedList;
import java.util.List;
/**
*
* @param <T> type of parameter
* @author jomu
*/
public abstract class Parameter<T> {
/** the name of the parameter */
private String name;
/** the long description of this parameter */
private String description;
/** boolean flag if this is a mandatory parameter or not */
private boolean mandatory;
/** the type of the value object for this paramterer */
// private T type;
/** the string converter to convert the object to string and back again */
private StringConverter<T> stringConverter;
/** list of mandatory parameters, if this parameter is active */
private List<Parameter<?>> requiredParameters;
/** optional validator */
private Validator<T> validator;
/**
* creates a new mandatory string parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
*/
public Parameter(String name, StringConverter<T> converter) {
this.name = name;
this.description = name;
this.mandatory = true;
this.stringConverter = converter;
this.requiredParameters = new LinkedList<Parameter<?>>();
this.validator = null;
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param mandatory detremines if this is a mandatory parameter or not
*/
public Parameter(String name, StringConverter<T> converter, boolean mandatory) {
this(name, converter);
this.mandatory = mandatory;
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param description the long text description of this parameter
* @param mandatory detremines if this is a mandatory parameter or not
*/
public Parameter(String name, StringConverter<T> converter, String description, boolean mandatory) {
this(name, converter);
this.description = description;
this.mandatory = mandatory;
}
@Override
public String toString() {
return name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @return the description
*/
public String getDescription() {
return description;
}
/**
* @return the mandatory
*/
public boolean isMandatory() {
return mandatory;
}
/**
* @return the stringConverter
*/
public StringConverter<T> getStringConverter() {
return stringConverter;
}
/**
* adds a parameter to the list of required parameters
*
* @param param the parameter to add
*/
public void addRequiredParameter(Parameter param) {
if (!requiredParameters.contains(param)) {
requiredParameters.add(param);
}
}
/**
* returns the list of parameters the given parameter requires
*
* @return the list of parameters the given parameter requires
*/
public List<Parameter<?>> getRequiredParameter() {
return requiredParameters;
}
/**
* returns true, if the given value is part of the possible value list or if the given value list is true
*
* @param value the value to validate
* @return true if no value list is defined or value is part of the value list; false otherwise
*/
public boolean isValid(T value) {
if (validator == null) {
return true;
} else {
try {
validator.validate(value);
return true;
} catch (ValidationException ex) {
return false;
}
}
}
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o instanceof Parameter) {
Parameter param = (Parameter) o;
return param.getName().equals(getName());
} else {
return false;
}
}
@Override
public int hashCode() {
int hash = 7;
hash = 97 * hash + (this.name != null ? this.name.hashCode() : 0);
return hash;
}
/**
* @param validator the validator to set
*/
public void setValidator(Validator<T> validator) {
this.validator = validator;
}
}

49
configuration/src/main/java/de/muehlencord/shared/configuration/ParameterFactory.java Normal file
View File

@ -0,0 +1,49 @@
package de.muehlencord.shared.configuration;
import java.net.URI;
import java.util.Date;
/**
*
* @author jomu
*/
public abstract class ParameterFactory {
private ParameterFactory() {
// hide public constructor to force factory
}
public static Parameter getParameterInstance(String name, boolean mandatory, Class clazz) throws ConfigurationException {
if (clazz.equals(String.class)) {
return new StringParameter(name, mandatory);
} else if (clazz.equals(Boolean.class)) {
return new BooleanParameter(name, mandatory);
} else if (clazz.equals(Date.class)) {
return new DateParameter(name, mandatory);
} else if (clazz.equals(Integer.class)) {
return new IntegerParameter(name, mandatory);
} else if (clazz.equals(URI.class)) {
return new URIParameter(name, mandatory);
} else {
throw new ConfigurationException("Unsupported type " + clazz);
}
}
public static Parameter getParameterInstance(String name, boolean mandatory, Object value) throws ConfigurationException {
return getParameterInstance(name, mandatory, value.getClass());
}
public static Parameter getParameterInstance(String name) throws ConfigurationException {
return getParameterInstance(name, true, String.class);
}
public static Parameter getParameterInstance(String name, boolean mandatory) throws ConfigurationException {
return getParameterInstance(name, mandatory, String.class);
}
}

27
configuration/src/main/java/de/muehlencord/shared/configuration/StringConverter.java Normal file
View File

@ -0,0 +1,27 @@
package de.muehlencord.shared.configuration;
/**
*
* @param <T> the class type of the parameter value to convert
* @author jomu
*/
public interface StringConverter<T> {
/**
* Converter a parameter object to a string representation
* @param o the parameter value to convert
* @return the parameter value as string
* @throws ConverterException if the conversion fails
*/
public String toString (T o) throws ConverterException;
/**
* Converter a string to a the given type
* @param <V> the type of the converter
* @param s string representation of a parameter value to convert to an object
* @return the parameter value as object
* @throws ConverterException if the conversion fails
*/
public <V> V fromString (String s) throws ConverterException;
}

50
configuration/src/main/java/de/muehlencord/shared/configuration/StringParameter.java Normal file
View File

@ -0,0 +1,50 @@
package de.muehlencord.shared.configuration;
import de.muehlencord.shared.configuration.converter.StringStringConverter;
/**
* A String parameter
* @author joern@muehlencord.de
*/
public class StringParameter extends Parameter<String> {
/**
* creates a new mandatory parameter object using default string converter
*
* @param name the name of the parameter
*/
public StringParameter(String name) {
super(name, new StringStringConverter(), true);
}
/**
* creates a new mandatory parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
*/
public StringParameter(String name, StringConverter<String> converter) {
super(name, converter, true);
}
/**
* creates a new parameter object using default string converter
*
* @param name the name of the parameter
* @param mandatory detremines if this is a mandatory parameter or not
*/
public StringParameter(String name, boolean mandatory) {
super(name, new StringStringConverter(), mandatory);
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param mandatory detremines if this is a mandatory parameter or not
*/
public StringParameter(String name, StringConverter<String> converter, boolean mandatory) {
super(name, converter, mandatory);
}
}

52
configuration/src/main/java/de/muehlencord/shared/configuration/URIParameter.java Normal file
View File

@ -0,0 +1,52 @@
package de.muehlencord.shared.configuration;
import de.muehlencord.shared.configuration.converter.URIStringConverter;
import java.net.URI;
/**
* A URI parameter
* @author joern@muehlencord.de
*/
public class URIParameter extends Parameter<URI> {
/**
* creates a new mandatory parameter object using default string converter
*
* @param name the name of the parameter
*/
public URIParameter(String name) {
super(name, new URIStringConverter(), true);
}
/**
* creates a new mandatory parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
*/
public URIParameter(String name, StringConverter<URI> converter) {
super(name, converter, true);
}
/**
* creates a new parameter object using default string converter
*
* @param name the name of the parameter
* @param mandatory detremines if this is a mandatory parameter or not
*/
public URIParameter(String name, boolean mandatory) {
super(name, new URIStringConverter(), mandatory);
}
/**
* creates a new parameter object
*
* @param name the name of the parameter
* @param converter the converter object to convert the value of the parameter to string and vice versa
* @param mandatory detremines if this is a mandatory parameter or not
*/
public URIParameter(String name, StringConverter<URI> converter, boolean mandatory) {
super(name, converter, mandatory);
}
}

36
configuration/src/main/java/de/muehlencord/shared/configuration/ValidationException.java Normal file
View File

@ -0,0 +1,36 @@
package de.muehlencord.shared.configuration;
/**
*
* @author joern@muehlencord.de
*/
public class ValidationException extends Exception {
/**
* Creates a new instance of
* <code>ValidationException</code> without detail message.
*/
public ValidationException() {
}
/**
* Constructs an instance of
* <code>ValidationException</code> with the specified detail message.
*
* @param msg the detail message.
*/
public ValidationException(String msg) {
super(msg);
}
/**
* Constructs an instance of
* <code>ValidationException</code> with the specified detail message.
*
* @param msg the detail message.
* @param th the root cause
*/
public ValidationException(String msg, Throwable th) {
super(msg, th);
}
}

17
configuration/src/main/java/de/muehlencord/shared/configuration/Validator.java Normal file
View File

@ -0,0 +1,17 @@
package de.muehlencord.shared.configuration;
/**
*
* @param <T> the type of the validator
* @author joern@muehlencord.de
*/
public interface Validator<T> {
/**
* validates the parameter value
*
* @param value the value of the parameter to validate
* @throws ValidationException if the value is not valid according to the validator configuration
*/
public void validate(T value) throws ValidationException;
}

21
configuration/src/main/java/de/muehlencord/shared/configuration/converter/BooleanStringConverter.java Normal file
View File

@ -0,0 +1,21 @@
package de.muehlencord.shared.configuration.converter;
import de.muehlencord.shared.configuration.ConverterException;
import de.muehlencord.shared.configuration.StringConverter;
/**
*
* @author joern@muehlencord.de
*/
public class BooleanStringConverter implements StringConverter<Boolean> {
@Override
public String toString(Boolean o) throws ConverterException {
return o.toString();
}
@Override
public Boolean fromString(String s) throws ConverterException {
return Boolean.parseBoolean(s);
}
}

49
configuration/src/main/java/de/muehlencord/shared/configuration/converter/DateStringConverter.java Normal file
View File

@ -0,0 +1,49 @@
package de.muehlencord.shared.configuration.converter;
import de.muehlencord.shared.configuration.ConverterException;
import de.muehlencord.shared.configuration.StringConverter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
*
* @author jomu
*/
public class DateStringConverter implements StringConverter<Date> {
/**
* dateformat to convert from string to date and vice versa
*/
private static final String format = "yyyy-MM-dd HH:mm:ss";
/**
* Converter a parameter object to a string representation
*
* @param d the parameter value to convert
* @return the parameter value as string
*/
@Override
public String toString(Date d) {
SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.US);
return sdf.format(d);
}
/**
* Converter a string to date
*
* @param s string representation of a parameter value to convert to an object
* @return the parameter value as date
*
* @throws ConverterException if the conversion fails
*/
@Override
public Date fromString(String s) throws ConverterException {
try {
SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.US);
return sdf.parse(s);
} catch (Exception ex) {
throw new ConverterException("Error while converting " + s + "*to date. Reason: " + ex.getMessage(), ex);
}
}
}

20
configuration/src/main/java/de/muehlencord/shared/configuration/converter/IntegerStringConverter.java Normal file
View File

@ -0,0 +1,20 @@
package de.muehlencord.shared.configuration.converter;
import de.muehlencord.shared.configuration.ConverterException;
import de.muehlencord.shared.configuration.StringConverter;
/**
*
* @author jomu
*/
public class IntegerStringConverter implements StringConverter<Integer> {
public String toString(Integer o) throws ConverterException {
return o.toString();
}
public Integer fromString(String s) throws ConverterException {
return Integer.parseInt(s);
}
}

22
configuration/src/main/java/de/muehlencord/shared/configuration/converter/StringStringConverter.java Normal file
View File

@ -0,0 +1,22 @@
package de.muehlencord.shared.configuration.converter;
import de.muehlencord.shared.configuration.ConverterException;
import de.muehlencord.shared.configuration.StringConverter;
/**
*
* @author jomu
*/
public class StringStringConverter implements StringConverter<String> {
@Override
public String toString(String o) throws ConverterException {
return o;
}
@Override
public String fromString(String s) throws ConverterException {
return s;
}
}

23
configuration/src/main/java/de/muehlencord/shared/configuration/converter/URIStringConverter.java Normal file
View File

@ -0,0 +1,23 @@
package de.muehlencord.shared.configuration.converter;
import de.muehlencord.shared.configuration.ConverterException;
import de.muehlencord.shared.configuration.StringConverter;
import java.net.URI;
/**
*
* @author jomu
*/
public class URIStringConverter implements StringConverter<URI> {
@Override
public String toString(URI o) throws ConverterException {
return o.toString();
}
@Override
public URI fromString(String s) throws ConverterException {
return URI.create(s);
}
}

27
configuration/src/main/java/de/muehlencord/shared/configuration/validator/IntgerRangeValidator.java Normal file
View File

@ -0,0 +1,27 @@
package de.muehlencord.shared.configuration.validator;
import de.muehlencord.shared.configuration.ValidationException;
import de.muehlencord.shared.configuration.Validator;
/**
*
* @author joern@muehlencord.de
*/
public class IntgerRangeValidator implements Validator<Integer> {
private Integer lowerBoundary;
private Integer upperBoundary;
public IntgerRangeValidator(Integer lb, Integer ub) {
this.lowerBoundary = lb;
this.upperBoundary = ub;
}
@Override
public void validate(Integer value) throws ValidationException {
if ((value > upperBoundary) || (value < lowerBoundary)) {
throw new ValidationException("Value must be between " + lowerBoundary + " and " + upperBoundary + " but is " + value);
}
}
}

32
configuration/src/main/java/de/muehlencord/shared/configuration/validator/StringValueListValidator.java Normal file
View File

@ -0,0 +1,32 @@
package de.muehlencord.shared.configuration.validator;
import de.muehlencord.shared.configuration.ValidationException;
import de.muehlencord.shared.configuration.Validator;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
/**
*
* @author joern@muehlencord.de
*/
public class StringValueListValidator implements Validator<String> {
private List<String> valueList;
public StringValueListValidator() {
this.valueList = new LinkedList<String>();
}
public StringValueListValidator(String... values) {
this();
valueList.addAll(Arrays.asList(values));
}
@Override
public void validate(String value) throws ValidationException {
if (!valueList.contains(value)) {
throw new ValidationException("Value " + value + " not valid. One of " + valueList.toString() + " expected");
}
}
}

38
configuration/src/test/java/de/muehlencord/shared/configuration/AppTest.java Normal file
View File

@ -0,0 +1,38 @@
package de.muehlencord.shared.configuration;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest
extends TestCase
{
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName )
{
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite()
{
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
*/
public void testApp()
{
assertTrue( true );
}
}