/*******************************************************************************
* Copyright 2006 - 2012 Vienna University of Technology,
* Department of Software Technology and Interactive Systems, IFS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This work originates from the Planets project, co-funded by the European Union under the Sixth Framework Programme.
******************************************************************************/
package eu.scape_project.planning.model.transform;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.persistence.CascadeType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;
import eu.scape_project.planning.model.TargetValueObject;
import eu.scape_project.planning.model.values.INumericValue;
import eu.scape_project.planning.model.values.IOrdinalValue;
import eu.scape_project.planning.model.values.OrdinalValue;
import eu.scape_project.planning.model.values.TargetValue;
import eu.scape_project.planning.validation.ValidationError;
/**
* Transforms {@link OrdinalValue ordinal values} by defining a mapping from
* their values to a numeric target value.
*
* @author Hannes Kulovits
*/
@Entity
@DiscriminatorValue("O")
public class OrdinalTransformer extends Transformer {
private static final long serialVersionUID = 8652623297851724108L;
/**
* The key member of Map must be renamed to key_name otherwise derby
* complains. 'key' seems to be a keyword. We use a LinkedHashMap, to
* preserve the order of the entries during ex-/import.
*/
// @IndexColumn(name="key_name")
@OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@Fetch(FetchMode.SELECT)
private Map<String, TargetValueObject> mapping = new LinkedHashMap<String, TargetValueObject>();
public Map<String, TargetValueObject> getMapping() {
return mapping;
}
public void setMapping(Map<String, TargetValueObject> mapping) {
this.mapping = mapping;
}
/**
* This operation is not supported. Always throws an
* {@link UnsupportedOperationException}
*
* @throws UnsupportedOperationException
* because this is the ordinal transformer.
*/
public TargetValue transform(INumericValue v) {
throw new UnsupportedOperationException("Cannot transform numeric values. only ordinal ones!");
}
/**
* Returns the transformed value, i.e. the numeric target value
* corresponding to the provided ordinal value according to the specified
* {@link #mapping}.
*
* @param v
* the ordinal value to be transformed
* @return {@link TargetValue} transformed value.
*/
public TargetValue transform(IOrdinalValue v) {
TargetValue t = new TargetValue();
TargetValueObject o = mapping.get(v.getValue());
t.setValue(o.getValue());
return t;
}
/**
* Checks if all mappings are set and correctly specified, i.e. between 0.0
* and 5.0. This is now a double-check as we already have a
* {@link TargetValueValidator} that takes care of that. We still leave the
* checks in because it can't hurt.
*/
public boolean isTransformable(List<ValidationError> errors) {
boolean result = true;
for (String key : mapping.keySet()) {
TargetValueObject value = mapping.get(key);
// Target values are initialised and set to 0.0, so we can assume it
// is not null:
if ((value.getValue() < 0.0) || (value.getValue() > 5.0)) {
result = false;
errors.add(new ValidationError("Transformation of '" + key + "' to " + value.getValue()
+ ": For ordinal values only target values between 0.0 and 5.0 are allowed.", this));
}
}
return result;
}
@Override
public Transformer clone() {
OrdinalTransformer t = new OrdinalTransformer();
t.setId(0);
for (String s : mapping.keySet()) {
TargetValueObject tvo = mapping.get(s);
t.getMapping().put(s, tvo.clone());
}
return t;
}
}