Commit 58afc74b authored by Eric Tobias's avatar Eric Tobias

Added ConditionalCorona and its builders

parent df5025b5
......@@ -2,7 +2,7 @@
<modelVersion>4.0.0</modelVersion>
<groupId>lu.list.itis.dkd.tui</groupId>
<artifactId>tulip-cps</artifactId>
<version>1.3.0</version>
<version>1.3.1</version>
<name>TULIP Complex Problem Solving</name>
<licenses>
......@@ -49,11 +49,6 @@
<artifactId>tulip</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>dk.ange</groupId>
<artifactId>javaoctave</artifactId>
......
......@@ -37,7 +37,7 @@ import javax.script.ScriptException;
*
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.0
* @version 1.3.0
* @version 1.3.1
*/
@NonNullByDefault
public class Equation {
......@@ -132,4 +132,18 @@ public class Equation {
public void saveState() {
lockedMapping = mapping.lock();
}
/**
* Method used to update the mapping with a variable, that is, to update the reference to a
* variable so that the mapping will correctly map all changes of the variable. <br>
* <br>
* <u>Note:</u> This method depends on the equality of variables being by name and unit.
*
* @param variable
* The variable to update the reference for.
* @see Variable#equals(Object)
*/
public void updateMapping(Variable variable) {
mapping.updateVariableReference(variable);
}
}
\ No newline at end of file
......@@ -23,6 +23,7 @@ package lu.list.itis.dkd.tui.cps.system;
import lu.list.itis.dkd.dbc.annotation.NonNullByDefault;
import lu.list.itis.dkd.tui.cps.Phenomenon;
import lu.list.itis.dkd.tui.cps.utility.Externalization;
import lu.list.itis.dkd.tui.cps.variable.BooleanVariable;
import lu.list.itis.dkd.tui.cps.variable.Variable;
import lu.list.itis.dkd.tui.cps.variable.tangible.TangibleNumericalVariable;
......@@ -36,9 +37,11 @@ import org.jdom2.input.SAXBuilder;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Properties;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
......@@ -76,9 +79,9 @@ public class EquationSystemBuilder {
private static final Logger logger = Logger.getLogger(EquationSystemBuilder.class.getSimpleName());
/**
* @param properties
* Constructor initializing all fields.
*/
public EquationSystemBuilder(Properties properties) {
public EquationSystemBuilder() {
independentVariables = new ConcurrentHashMap<String, Variable>();
dependentVariables = new ConcurrentHashMap<String, Variable>();
......@@ -150,8 +153,7 @@ public class EquationSystemBuilder {
if (Strings.isNullOrEmpty(name)) {
throw new EquationSystemException("For each output the name needs to be defined!"); //$NON-NLS-1$
}
outputVariables.put(name, new TangibleNumericalVariable(name, Strings.nullToEmpty(unit), 0));
addVariable(outputVariables, name, unit);
}
}
......@@ -197,13 +199,37 @@ public class EquationSystemBuilder {
}
if (!dependentVariables.containsKey(parameterName) && !independentVariables.containsKey(parameterName)) {
independentVariables.put(parameterName, new TangibleNumericalVariable(parameterName, parameterUnit, 0));
addVariable(independentVariables, parameterName, parameterUnit);
}
}
equationParameters.put(equationName, _equationParameters);
}
/**
* Method used to create a new Variable and add it to a parameterized map. Numerical variables
* will be initialized to 0, boolean variables to <code>false</code>. Note that the switch to
* decide on which variable to initialize is done by the unit name. All variables are by default
* numerical variables unless the unit is set to "boolean".
*
* @param map
* The map to add the variable to.
* @param name
* The name of the variable to create.
* @param unit
* The name of the unit the variable will carry.
*/
private void addVariable(Map<String, Variable> map, String name, String unit) {
switch (unit) {
case "boolean": //$NON-NLS-1$
map.put(name, new BooleanVariable(name, false));
break;
default:
map.put(name, new TangibleNumericalVariable(name, unit, 0));
break;
}
}
private void addResultDependencies(Element equation) {
String equationName = equation.getChildText(Externalization.NAME_ELEMENT);
List<Element> results = equation.getChild(Externalization.RESULTS_ELEMENT).getChildren(Externalization.RESULT_ELEMENT);
......@@ -226,7 +252,7 @@ public class EquationSystemBuilder {
if (outputVariables.containsKey(resultName)) {
dependentVariables.put(resultName, outputVariables.get(resultName));
} else {
dependentVariables.put(resultName, new TangibleNumericalVariable(resultName, resultUnit, 0));
addVariable(dependentVariables, resultName, resultUnit);
}
}
if (this.independentVariables.containsKey(resultName)) {
......@@ -382,32 +408,58 @@ public class EquationSystemBuilder {
extractEquations(rootNode.getChild(Externalization.EQUATIONS_ELEMENT).getChildren(Externalization.EQUATION_ELEMENT));
}
/**
* @return
* Method used to build an equation system from a provided element.
*
* @param element
* The element holding, as child elements, the required data to build the equation
* system.
* @throws EquationSystemException
* Thrown when an error in the equation system specification prevented the equation
* system from being built.
*/
public ConcurrentHashMap<String, Variable> getInputVariables() {
return this.independentVariables;
public void buildFromElement(Element element) throws EquationSystemException {
if (!element.getName().equalsIgnoreCase(Externalization.SYSTEM_ELEMENT)) {
element = element.getChild(Externalization.SYSTEM_ELEMENT);
}
extractOutputs(element.getChildren(Externalization.OUTPUTS_ELEMENT));
extractEquations(element.getChild(Externalization.EQUATIONS_ELEMENT).getChildren(Externalization.EQUATION_ELEMENT));
}
/**
* @return
* Simple getter method for the input variables.
*
* @return The map of input variables.
*/
public ConcurrentHashMap<String, Variable> getOutputVariables() {
return this.outputVariables;
public Map<String, Variable> getInputVariables() {
return independentVariables;
}
/**
* @return
* Simple getter method for outputVariables.
*
* @return The map of output variables.
*/
public ConcurrentHashMap<String, Variable> getDependentVariables() {
return this.dependentVariables;
public Map<String, Variable> getOutputVariables() {
return outputVariables;
}
/**
* @return
* Simple getter method for returning all equations held by this instance.
*
* @return A Set holding all equations.
*/
public ConcurrentHashMap<String, Phenomenon> getPhenomena() {
return this.phenomena;
public Set<Equation> getEquations() {
Set<Equation> equationSet = new HashSet<>();
equations.forEachValue(10, e -> equationSet.addAll(e.getEquations().values()));
return equationSet;
}
public ConcurrentHashMap<String, LinearEquationSystem> getEquationSystem() {
return equations;
}
}
\ No newline at end of file
......@@ -38,7 +38,7 @@ import javax.script.ScriptEngineManager;
*
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.0
* @version 1.3.0
* @version 1.3.1
*/
@NonNullByDefault
public class LinearEquationSystem extends System {
......@@ -108,4 +108,13 @@ public class LinearEquationSystem extends System {
equation.saveState();
}
}
/**
* Simple getter method for equations.
*
* @return The value of equations.
*/
public ConcurrentHashMap<Mapping, Equation> getEquations() {
return equations;
}
}
\ No newline at end of file
......@@ -26,6 +26,7 @@ import lu.list.itis.dkd.tui.cps.variable.Variable;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.LinkedHashSet;
/**
......@@ -34,11 +35,11 @@ import java.util.LinkedHashSet;
*
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.0
* @version 1.3.0
* @version 1.3.1
*/
@NonNullByDefault
public class Mapping {
private LinkedHashSet<Variable> independentVariables;
private Collection<Variable> independentVariables;
private Variable dependentVariable;
/**
......@@ -49,7 +50,7 @@ public class Mapping {
* @param dependentVariable
* The dependent variable of the mapping.
*/
public Mapping(LinkedHashSet<Variable> independentVariables, Variable dependentVariable) {
public Mapping(Collection<Variable> independentVariables, Variable dependentVariable) {
Preconditions.checkArgument(!independentVariables.isEmpty(), "The set of input variables cannot be empty."); //$NON-NLS-1$
this.independentVariables = independentVariables;
this.dependentVariable = dependentVariable;
......@@ -60,7 +61,7 @@ public class Mapping {
*
* @return The value of independentVariables.
*/
public LinkedHashSet<Variable> getIndependentVariables() {
public Collection<Variable> getIndependentVariables() {
return independentVariables;
}
......@@ -150,4 +151,22 @@ public class Mapping {
return new Mapping(clones, dependentVariable.clone());
}
/**
* Method for updating a reference to an independent variable. The method will add the variable
* to the collection of independent variables this mapping instance will contain <b>iff</b> the
* mapping already mapped the variable prior to this call. <br>
* <br>
* <u>Note:</u> This method depends on the equality of variables being by name and unit.
*
* @param variable
* The variable to update the reference for.
* @see Variable#equals(Object)
*/
public void updateVariableReference(Variable variable) {
if (independentVariables.contains(variable)) {
independentVariables.remove(variable);
independentVariables.add(variable);
}
}
}
\ No newline at end of file
......@@ -24,13 +24,14 @@ import lu.list.itis.dkd.tui.cps.variable.Variable;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.LinkedHashSet;
/**
*
* @author Nico Mack [nico.mack@list.lu]
* @since 1.1
* @version 1.3.0
* @version 1.3.1
*/
public class OctaveMapping extends Mapping {
private LinkedHashSet<Variable> dependentVariables;
......@@ -61,7 +62,7 @@ public class OctaveMapping extends Mapping {
String separator = ""; //$NON-NLS-1$
StringBuilder renderer = new StringBuilder();
LinkedHashSet<Variable> independentVariables = super.getIndependentVariables();
Collection<Variable> independentVariables = super.getIndependentVariables();
for (Variable variable : independentVariables) {
renderer.append(separator).append(variable.getName());
separator = ", "; //$NON-NLS-1$
......@@ -86,7 +87,7 @@ public class OctaveMapping extends Mapping {
*/
@Override
public synchronized Mapping lock() {
LinkedHashSet<Variable> independentVariables = super.getIndependentVariables();
Collection<Variable> independentVariables = super.getIndependentVariables();
LinkedHashSet<Variable> clonedIndependentVariables = new LinkedHashSet<>();
for (Variable variable : independentVariables) {
......
......@@ -28,7 +28,7 @@ import java.util.Vector;
/**
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.1
* @version 1.3.0
* @version 1.3.1
*/
public class BooleanVariable extends Variable {
......@@ -36,11 +36,10 @@ public class BooleanVariable extends Variable {
/**
* @param name
* @param unit
* @param value
*/
public BooleanVariable(String name, String unit, boolean value) {
super(name, unit);
public BooleanVariable(String name, boolean value) {
super(name, "boolean"); //$NON-NLS-1$
this.value = value;
}
......@@ -68,7 +67,7 @@ public class BooleanVariable extends Variable {
/** {@inheritDoc} */
@Override
public Variable clone() {
BooleanVariable variable = new BooleanVariable(name, unit, value);
BooleanVariable variable = new BooleanVariable(name, value);
variable.listeners = new Vector<>(listeners);
return variable;
}
......
......@@ -29,6 +29,7 @@ import lu.list.itis.dkd.tui.cps.variable.tangible.TangibleNumericalVariable;
import lu.list.itis.dkd.tui.utility.Point;
import lu.list.itis.dkd.tui.widget.builder.BaseValueWidgetBuilder;
import lu.list.itis.dkd.tui.widget.builder.ValueWidgetBuilder;
import lu.list.itis.dkd.tui.widget.corona.ConditionalCorona;
import lu.list.itis.dkd.tui.widget.corona.Corona;
import java.awt.Graphics2D;
......@@ -67,7 +68,7 @@ public final class ValueWidget extends BaseWidget implements InformationProvider
private double stepAngle;
private double steps;
private double delta;
// private double delta;
private double dialAngle;
/**
......@@ -103,7 +104,7 @@ public final class ValueWidget extends BaseWidget implements InformationProvider
dialAngle = lowerStopAngle;
steps = (upperBound - lowerBound + 1) / stepSize;
stepAngle = (upperStopAngle - lowerStopAngle) / steps;
delta = Double.NaN;
// delta = Double.NaN;
}
@Override
......@@ -181,13 +182,18 @@ public final class ValueWidget extends BaseWidget implements InformationProvider
}
/**
* Simple setter method for variable.
* This method will set the variable held by this widget as well as forward the setter to all
* {@link ConditionalCorona} instances attached to this widget instance.
*
* @param variable
* The value to set variable to.
*/
public void setVariable(TangibleNumericalVariable variable) {
this.variable = variable;
for (ConditionalCorona conditionalCorona : getCoronas(ConditionalCorona.class)) {
conditionalCorona.addVariable(variable);
}
}
@SuppressWarnings("unchecked")
......
/**
* Copyright Luxembourg Institute of Science and Technology, 2016. All rights reserved. If you wish
* to use this code for any purpose, please contact the author(s).
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package lu.list.itis.dkd.tui.widget.corona;
import lu.list.itis.dkd.dbc.annotation.NonNullByDefault;
import lu.list.itis.dkd.tui.cps.system.Equation;
import lu.list.itis.dkd.tui.cps.variable.BooleanVariable;
import lu.list.itis.dkd.tui.cps.variable.Variable;
import lu.list.itis.dkd.tui.utility.Point;
import lu.list.itis.dkd.tui.widget.corona.builder.ConditionalCoronaBuilder;
import com.google.common.base.Predicate;
import com.google.common.collect.Maps;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.util.Map;
import java.util.Set;
/**
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.3
* @version 1.3.1
*/
@NonNullByDefault
public class ConditionalCorona extends Corona {
private Map<String, Variable> outputs;
private Set<Equation> equations;
private Map<Variable, java.awt.Image> images;
/**
* Predicate used to filter variables and check whether they contain <code>true</code> as a
* value if they are {@link BooleanVariable} instances in the first place. If the variable does
* not contain true or isn't a {@link BooleanVariable} instance, the predicate will return
* <code>false</code>.
*/
private Predicate<Variable> trigger = new Predicate<Variable>() {
@Override
public boolean apply(Variable variable) {
return variable instanceof BooleanVariable ? ((BooleanVariable) variable).getValue() : false;
}
};
/**
* @param builder
*
*/
public ConditionalCorona(ConditionalCoronaBuilder builder) {
super(builder);
this.outputs = builder.outputs;
this.equations = builder.equations;
this.images = builder.images;
}
/** {@inheritDoc} */
@Override
public void paint(Graphics2D canvas) {
if (!active) {
return;
}
centre.toScreenCoordinates();
if (initialTranslation != null) {
initialTranslation.toScreenCoordinates();
} else {
initialTranslation = new Point();
}
Point drawAt = centre.add(initialTranslation);
AffineTransform rotation = new AffineTransform();
rotation.rotate(rotateWithHandle ? drawAt.getAngle() : initialTranslation != null ? initialTranslation.getAngle() : 0, centre.getX(), centre.getY());
rotation.translate(drawAt.x, drawAt.y);
updateTriggers();
for (java.awt.Image image : Maps.filterKeys(images, trigger).values()) {
AffineTransform innerRotation = (AffineTransform) rotation.clone();
if (spinOnCoronaCentre) {
innerRotation.rotate(rotateWithHandle ? -drawAt.getAngle() : 0);
innerRotation.translate(-image.getWidth(null) / 2, -image.getHeight(null) / 2);
}
innerRotation.transform(new Point(), drawAt);
if (Double.compare(initialRotation, 0d) != 0) {
AffineTransform transformation = new AffineTransform();
transformation.rotate(initialRotation, spinOnCoronaCentre ? drawAt.getX() + image.getWidth(null) / 2 : drawAt.getX(), spinOnCoronaCentre ? drawAt.getY() + image.getHeight(null) / 2 : drawAt.getY());
canvas.setTransform(transformation);
}
canvas.drawImage(image, (int) drawAt.x, (int) drawAt.y, null);
}
canvas.setTransform(new AffineTransform());
}
private void updateTriggers() {
for (Equation equation : equations) {
equation.evaluate();
}
}
/**
* Method used to add a variable to the map of variables held by this corona.
*
* @param variable
* The variable to add.
*/
public void addVariable(Variable variable) {
equations.forEach(e -> e.updateMapping(variable));
}
}
\ No newline at end of file
/**
* Copyright Luxembourg Institute of Science and Technology, 2016. All rights reserved. If you wish
* to use this code for any purpose, please contact the author(s).
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package lu.list.itis.dkd.tui.widget.corona.builder;
import lu.list.itis.dkd.tui.cps.system.Equation;
import lu.list.itis.dkd.tui.cps.system.EquationSystemBuilder;
import lu.list.itis.dkd.tui.cps.system.EquationSystemException;
import lu.list.itis.dkd.tui.cps.system.LinearEquationSystem;
import lu.list.itis.dkd.tui.cps.variable.Variable;
import lu.list.itis.dkd.tui.exception.BuildException;
import lu.list.itis.dkd.tui.utility.Externalization;
import lu.list.itis.dkd.tui.widget.corona.ConditionalCorona;
import org.jdom2.Element;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.imageio.ImageIO;
/**
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.3
* @version 1.3.1
* @param <B>
* The concrete builder.
*/
public abstract class BaseConditionalCoronaBuilder<B extends BaseConditionalCoronaBuilder<B>> extends CoronaBuilder<B> {
public Map<String, Variable> outputs;
public Set<Equation> equations;
public Map<Variable, java.awt.Image> images = new HashMap<>();
ConcurrentHashMap<String, LinearEquationSystem> equationSystems;
/**
* @param element
* @throws BuildException
*/
public BaseConditionalCoronaBuilder(Element element) throws BuildException {
super(element);
EquationSystemBuilder equationSystemBuilder = new EquationSystemBuilder();
try {
equationSystemBuilder.buildFromElement(element);
} catch (EquationSystemException ese) {
throw new BuildException("The equation could not be built!", ese); //$NON-NLS-1$
}
outputs = equationSystemBuilder.getOutputVariables();
equations = equationSystemBuilder.getEquations();
equationSystems = equationSystemBuilder.getEquationSystem();
try {
List<Element> imageElements = element.getChild(Externalization.IMAGES_ELEMENT).getChildren(Externalization.IMAGE_ELEMENT);
for (Element imageElement : imageElements) {
Variable trigger = outputs.get(imageElement.getChildText(Externalization.TRIGGER_ELEMENT));
java.awt.Image image = ImageIO.read(new File(imageElement.getChildText(Externalization.ASSET_ELEMENT)));
if (null == trigger || null == image) {
throw new BuildException("Neither the trigger nor the image may be null!"); //$NON-NLS-1$
}
images.put(trigger, image);
}
} catch (NullPointerException npe) {
throw new BuildException("The provided image path may not be empty. To add no image, remove the \"image\" element!", npe); //$NON-NLS-1$
} catch (IllegalArgumentException iae) {
throw new BuildException("The image could not be read from the provided location. The location should be given as absolute path, i.e.: \"C:\\My Image\\image.jpeg\"!", iae); //$NON-NLS-1$
} catch (IOException ioe) {
throw new BuildException("The image could not be read!", ioe); //$NON-NLS-1$
}
}
/** {@inheritDoc} */
@Override
public abstract ConditionalCorona build();
}
\ No newline at end of file
/**
* Copyright Luxembourg Institute of Science and Technology, 2016. All rights reserved. If you wish
* to use this code for any purpose, please contact the author(s).
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package lu.list.itis.dkd.tui.widget.corona.builder;
import lu.list.itis.dkd.tui.exception.BuildException;
import lu.list.itis.dkd.tui.widget.corona.ConditionalCorona;
import org.jdom2.Element;
/**
* @author Eric Tobias [eric.tobias@list.lu]
* @since 1.3
* @version 1.3.1
*/
public class ConditionalCoronaBuilder extends BaseConditionalCoronaBuilder<ConditionalCoronaBuilder> {
/**
* @param rootElement
* @throws BuildException
*/
public ConditionalCoronaBuilder(Element rootElement) throws BuildException {
super(rootElement);
}
/** {@inheritDoc} */
@Override
public ConditionalCorona build() {
return new ConditionalCorona(this);
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment