From 1e616f0616034d5a80b97ff11ea8ba6ffbbce518 Mon Sep 17 00:00:00 2001 From: Robert von Burg Date: Fri, 20 Apr 2018 20:49:31 +0200 Subject: [PATCH] [Major] Refactored searching to allow for coercing of left side --- .../li/strolch/search/ExpressionBuilder.java | 4 + .../li/strolch/search/ExpressionsSupport.java | 104 +++++++++++++----- .../li/strolch/search/ParameterPredicate.java | 9 -- .../li/strolch/search/PredicatesSupport.java | 30 +++-- .../li/strolch/search/SearchPredicate.java | 8 +- .../java/li/strolch/search/ValueCoercer.java | 6 + .../predicates/AbstractSearchPredicate.java | 23 ++++ .../search/predicates/ContainsPredicate.java | 17 +++ .../search/predicates/EndsWithPredicate.java | 17 +++ .../search/predicates/InRangePredicate.java | 26 +++++ .../search/predicates/IsEqualToPredicate.java | 17 +++ .../search/predicates/IsInPredicate.java | 17 +++ .../search/predicates/NotPredicate.java | 24 ++++ .../predicates/StartsWithPredicate.java | 17 +++ .../li/strolch/search/StrolchSearchTest.java | 5 + .../li/strolch/model/StrolchValueType.java | 83 +++++++++++--- .../model/parameter/BooleanParameter.java | 5 + .../model/parameter/DateParameter.java | 5 + .../model/parameter/DurationParameter.java | 5 + .../model/parameter/FloatListParameter.java | 5 + .../model/parameter/FloatParameter.java | 5 + .../model/parameter/IntegerListParameter.java | 5 + .../model/parameter/IntegerParameter.java | 5 + .../model/parameter/LongListParameter.java | 5 + .../model/parameter/LongParameter.java | 5 + .../li/strolch/model/parameter/Parameter.java | 6 + .../model/parameter/StringListParameter.java | 5 + .../model/parameter/StringParameter.java | 5 + .../java/li/strolch/utils/ObjectHelper.java | 4 + 29 files changed, 402 insertions(+), 70 deletions(-) delete mode 100644 li.strolch.agent/src/main/java/li/strolch/search/ParameterPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/ValueCoercer.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/AbstractSearchPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/ContainsPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/EndsWithPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/InRangePredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/IsEqualToPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/IsInPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/NotPredicate.java create mode 100644 li.strolch.agent/src/main/java/li/strolch/search/predicates/StartsWithPredicate.java diff --git a/li.strolch.agent/src/main/java/li/strolch/search/ExpressionBuilder.java b/li.strolch.agent/src/main/java/li/strolch/search/ExpressionBuilder.java index 2fe18a3f4..bafa008f8 100644 --- a/li.strolch.agent/src/main/java/li/strolch/search/ExpressionBuilder.java +++ b/li.strolch.agent/src/main/java/li/strolch/search/ExpressionBuilder.java @@ -7,6 +7,10 @@ public interface ExpressionBuilder { Object extract(StrolchRootElement element); + default ValueCoercer getValueCoercer(StrolchRootElement context) { + return e -> e; + } + default SearchExpression isEqualTo(Object right) { return element -> PredicatesSupport.isEqualTo(right).matches(extract(element)); } diff --git a/li.strolch.agent/src/main/java/li/strolch/search/ExpressionsSupport.java b/li.strolch.agent/src/main/java/li/strolch/search/ExpressionsSupport.java index ca7652f56..74d22f9e3 100644 --- a/li.strolch.agent/src/main/java/li/strolch/search/ExpressionsSupport.java +++ b/li.strolch.agent/src/main/java/li/strolch/search/ExpressionsSupport.java @@ -3,6 +3,7 @@ package li.strolch.search; import li.strolch.model.*; import li.strolch.model.activity.Activity; import li.strolch.model.parameter.Parameter; +import li.strolch.utils.iso8601.ISO8601FormatFactory; public class ExpressionsSupport { @@ -10,58 +11,111 @@ public class ExpressionsSupport { return element -> !expression.matches(element); } - public static ExpressionBuilder id() { - return StrolchElement::getId; - } - public static SearchExpression id(SearchPredicate predicate) { return element -> predicate.matches(element.getId()); } - public static ExpressionBuilder name() { - return StrolchElement::getName; + public static ExpressionBuilder id() { + return StrolchElement::getId; } public static SearchExpression name(SearchPredicate predicate) { return element -> predicate.matches(element.getName()); } - public static ExpressionBuilder date() { - return element -> ((Order) element).getDate(); + public static ExpressionBuilder name() { + return StrolchElement::getName; } public static SearchExpression date(SearchPredicate predicate) { - return element -> predicate.matches(((Order) element).getDate()); + ExpressionBuilder eb = date(); + return element -> predicate.coerce(eb.getValueCoercer(element)).matches(eb); } - public static ExpressionBuilder state() { - return element -> { - if (element instanceof Order) - return ((Order) element).getState(); - if (element instanceof Activity) - return ((Activity) element).getState(); - throw new IllegalArgumentException(element.getObjectType() + " does not have a state!"); + public static ExpressionBuilder date() { + return new ExpressionBuilder() { + + @Override + public ValueCoercer getValueCoercer(StrolchRootElement context) { + return e -> { + if (!(e instanceof String)) + return e; + return ISO8601FormatFactory.getInstance().parseDate((String) e); + }; + } + + @Override + public Object extract(StrolchRootElement element) { + return ((Order) element).getDate(); + } }; } public static SearchExpression state(SearchPredicate predicate) { - return element -> predicate.matches(state().extract(element)); + ExpressionBuilder eb = state(); + return element -> predicate.coerce(eb.getValueCoercer(element)).matches(eb.extract(element)); } - public static ExpressionBuilder param(String bagId, String paramId) { - return element -> { - ParameterBag bag = element.getParameterBag(bagId); - if (bag == null) - return null; + public static ExpressionBuilder state() { + return new ExpressionBuilder() { - Parameter param = bag.getParameter(paramId); - return param == null ? null : param.getValue(); + @Override + public ValueCoercer getValueCoercer(StrolchRootElement context) { + return e -> { + if (!(e instanceof String)) + return e; + return State.parse((String) e); + }; + } + + @Override + public Object extract(StrolchRootElement element) { + if (element instanceof Order) + return ((Order) element).getState(); + if (element instanceof Activity) + return ((Activity) element).getState(); + throw new IllegalArgumentException(element.getObjectType() + " does not have a state!"); + } }; } public static SearchExpression param(String bagId, String paramId, SearchPredicate predicate) { - return element -> predicate.matches(param(bagId, paramId).extract(element)); + ExpressionBuilder eb = param(bagId, paramId); + return element -> predicate.coerce(eb.getValueCoercer(element)).matches(eb.extract(element)); + } + + public static ExpressionBuilder param(String bagId, String paramId) { + return new ExpressionBuilder() { + + @Override + public ValueCoercer getValueCoercer(StrolchRootElement context) { + return e -> { + if (!(e instanceof String)) + return e; + + ParameterBag bag = context.getParameterBag(bagId); + if (bag == null) + return e; + + Parameter param = bag.getParameter(paramId); + if (param == null) + return e; + + return param.getValueType().parseValue((String) e); + }; + } + + @Override + public Object extract(StrolchRootElement element) { + ParameterBag bag = element.getParameterBag(bagId); + if (bag == null) + return null; + + Parameter param = bag.getParameter(paramId); + return param == null ? null : param.getValue(); + } + }; } public static SearchExpression paramNull(String bagId, String paramId) { diff --git a/li.strolch.agent/src/main/java/li/strolch/search/ParameterPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/ParameterPredicate.java deleted file mode 100644 index 701d31867..000000000 --- a/li.strolch.agent/src/main/java/li/strolch/search/ParameterPredicate.java +++ /dev/null @@ -1,9 +0,0 @@ -package li.strolch.search; - -public class ParameterPredicate implements SearchPredicate { - - @Override - public boolean matches(Object value) { - return false; - } -} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/PredicatesSupport.java b/li.strolch.agent/src/main/java/li/strolch/search/PredicatesSupport.java index 00393cf65..9ecc2b240 100644 --- a/li.strolch.agent/src/main/java/li/strolch/search/PredicatesSupport.java +++ b/li.strolch.agent/src/main/java/li/strolch/search/PredicatesSupport.java @@ -1,61 +1,59 @@ package li.strolch.search; -import java.util.Date; - -import li.strolch.utils.ObjectHelper; +import li.strolch.search.predicates.*; import li.strolch.utils.collections.DateRange; public class PredicatesSupport { public static SearchPredicate isEqualTo(Object right) { - return left -> ObjectHelper.equals(left, right, false); + return new IsEqualToPredicate(right, false); } public static SearchPredicate isEqualToIgnoreCase(Object right) { - return left -> ObjectHelper.equals(left, right, true); + return new IsEqualToPredicate(right, true); } public static SearchPredicate isNotEqualTo(Object right) { - return left -> !ObjectHelper.equals(left, right, false); + return new IsEqualToPredicate(right, false).not(); } public static SearchPredicate isNotEqualToIgnoreCase(Object right) { - return left -> !ObjectHelper.equals(left, right, true); + return new IsEqualToPredicate(right, true).not(); } public static SearchPredicate startsWith(Object right) { - return left -> ObjectHelper.startsWith(left, right, false); + return new StartsWithPredicate(right, false); } public static SearchPredicate startsWithIgnoreCase(Object right) { - return left -> ObjectHelper.startsWith(left, right, true); + return new StartsWithPredicate(right, true); } public static SearchPredicate endsWith(Object right) { - return left -> ObjectHelper.endsWith(left, right, false); + return new EndsWithPredicate(right, false); } public static SearchPredicate endsWithIgnoreCase(Object right) { - return left -> ObjectHelper.endsWith(left, right, true); + return new EndsWithPredicate(right, true); } public static SearchPredicate contains(Object right) { - return left -> ObjectHelper.contains(left, right, false); + return new ContainsPredicate(right, false); } public static SearchPredicate containsIgnoreCase(Object right) { - return left -> ObjectHelper.contains(left, right, true); + return new ContainsPredicate(right, true); } public static SearchPredicate isIn(Object right) { - return left -> ObjectHelper.isIn(left, right, false); + return new IsInPredicate(right, false); } public static SearchPredicate isInIgnoreCase(Object right) { - return left -> ObjectHelper.isIn(left, right, true); + return new IsInPredicate(right, true); } public static SearchPredicate inRange(DateRange range) { - return left -> range.contains((Date) left); + return new InRangePredicate(range); } } diff --git a/li.strolch.agent/src/main/java/li/strolch/search/SearchPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/SearchPredicate.java index 7c47b60f0..3632ac8c6 100644 --- a/li.strolch.agent/src/main/java/li/strolch/search/SearchPredicate.java +++ b/li.strolch.agent/src/main/java/li/strolch/search/SearchPredicate.java @@ -1,10 +1,14 @@ package li.strolch.search; +import li.strolch.search.predicates.NotPredicate; + public interface SearchPredicate { - boolean matches(Object value); + boolean matches(Object left); + + SearchPredicate coerce(ValueCoercer coercer); default SearchPredicate not() { - return element -> !this.matches(element); + return new NotPredicate(this); } } diff --git a/li.strolch.agent/src/main/java/li/strolch/search/ValueCoercer.java b/li.strolch.agent/src/main/java/li/strolch/search/ValueCoercer.java new file mode 100644 index 000000000..44929637b --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/ValueCoercer.java @@ -0,0 +1,6 @@ +package li.strolch.search; + +public interface ValueCoercer { + + Object coerce(Object value); +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/AbstractSearchPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/AbstractSearchPredicate.java new file mode 100644 index 000000000..aa8a6cee5 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/AbstractSearchPredicate.java @@ -0,0 +1,23 @@ +package li.strolch.search.predicates; + +import li.strolch.search.SearchPredicate; +import li.strolch.search.ValueCoercer; + +public abstract class AbstractSearchPredicate implements SearchPredicate { + + private boolean coerced; + protected Object right; + + public AbstractSearchPredicate(Object right) { + this.right = right; + } + + public AbstractSearchPredicate coerce(ValueCoercer coercer) { + if (this.coerced) + return this; + + this.right = coercer.coerce(this.right); + this.coerced = true; + return this; + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/ContainsPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/ContainsPredicate.java new file mode 100644 index 000000000..581611ed1 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/ContainsPredicate.java @@ -0,0 +1,17 @@ +package li.strolch.search.predicates; + +import li.strolch.utils.ObjectHelper; + +public class ContainsPredicate extends AbstractSearchPredicate { + private boolean ignoreCase; + + public ContainsPredicate(Object right, boolean ignoreCase) { + super(right); + this.ignoreCase = ignoreCase; + } + + @Override + public boolean matches(Object left) { + return ObjectHelper.contains(left, this.right, this.ignoreCase); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/EndsWithPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/EndsWithPredicate.java new file mode 100644 index 000000000..fd1ec1ce8 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/EndsWithPredicate.java @@ -0,0 +1,17 @@ +package li.strolch.search.predicates; + +import li.strolch.utils.ObjectHelper; + +public class EndsWithPredicate extends AbstractSearchPredicate { + private final boolean ignoreCase; + + public EndsWithPredicate(Object right, boolean ignoreCase) { + super(right); + this.ignoreCase = ignoreCase; + } + + @Override + public boolean matches(Object left) { + return ObjectHelper.endsWith(left, this.right, this.ignoreCase); + } +} \ No newline at end of file diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/InRangePredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/InRangePredicate.java new file mode 100644 index 000000000..bf185b2f6 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/InRangePredicate.java @@ -0,0 +1,26 @@ +package li.strolch.search.predicates; + +import java.util.Date; + +import li.strolch.search.SearchPredicate; +import li.strolch.search.ValueCoercer; +import li.strolch.utils.collections.DateRange; + +public class InRangePredicate implements SearchPredicate { + private final DateRange range; + + public InRangePredicate(DateRange range) { + this.range = range; + } + + @Override + public boolean matches(Object left) { + return range.contains((Date) left); + } + + @Override + public SearchPredicate coerce(ValueCoercer coercer) { + // nothing to coerce + return this; + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/IsEqualToPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/IsEqualToPredicate.java new file mode 100644 index 000000000..5e2c9127f --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/IsEqualToPredicate.java @@ -0,0 +1,17 @@ +package li.strolch.search.predicates; + +import li.strolch.utils.ObjectHelper; + +public class IsEqualToPredicate extends AbstractSearchPredicate { + private final boolean ignoreCase; + + public IsEqualToPredicate(Object right, boolean ignoreCase) { + super(right); + this.ignoreCase = ignoreCase; + } + + @Override + public boolean matches(Object left) { + return ObjectHelper.equals(left, this.right, this.ignoreCase); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/IsInPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/IsInPredicate.java new file mode 100644 index 000000000..6977a20d2 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/IsInPredicate.java @@ -0,0 +1,17 @@ +package li.strolch.search.predicates; + +import li.strolch.utils.ObjectHelper; + +public class IsInPredicate extends AbstractSearchPredicate { + private final boolean ignoreCase; + + public IsInPredicate(Object right, boolean ignoreCase) { + super(right); + this.ignoreCase = ignoreCase; + } + + @Override + public boolean matches(Object left) { + return ObjectHelper.isIn(left, this.right, this.ignoreCase); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/NotPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/NotPredicate.java new file mode 100644 index 000000000..67f7386d6 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/NotPredicate.java @@ -0,0 +1,24 @@ +package li.strolch.search.predicates; + +import li.strolch.search.SearchPredicate; +import li.strolch.search.ValueCoercer; + +public class NotPredicate implements SearchPredicate { + + private final SearchPredicate predicate; + + public NotPredicate(SearchPredicate predicate) { + this.predicate = predicate; + } + + @Override + public SearchPredicate coerce(ValueCoercer coercer) { + this.predicate.coerce(coercer); + return this; + } + + @Override + public boolean matches(Object left) { + return !this.predicate.matches(left); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/search/predicates/StartsWithPredicate.java b/li.strolch.agent/src/main/java/li/strolch/search/predicates/StartsWithPredicate.java new file mode 100644 index 000000000..e6c30f007 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/search/predicates/StartsWithPredicate.java @@ -0,0 +1,17 @@ +package li.strolch.search.predicates; + +import li.strolch.utils.ObjectHelper; + +public class StartsWithPredicate extends AbstractSearchPredicate { + private final boolean ignoreCase; + + public StartsWithPredicate(Object right, boolean ignoreCase) { + super(right); + this.ignoreCase = ignoreCase; + } + + @Override + public boolean matches(Object left) { + return ObjectHelper.startsWith(left, this.right, this.ignoreCase); + } +} \ No newline at end of file diff --git a/li.strolch.agent/src/test/java/li/strolch/search/StrolchSearchTest.java b/li.strolch.agent/src/test/java/li/strolch/search/StrolchSearchTest.java index 091420734..bc7aed699 100644 --- a/li.strolch.agent/src/test/java/li/strolch/search/StrolchSearchTest.java +++ b/li.strolch.agent/src/test/java/li/strolch/search/StrolchSearchTest.java @@ -378,16 +378,21 @@ public class StrolchSearchTest { .and(param(BAG_ID, PARAM_STRING_ID, endsWithIgnoreCase("LCH"))) .and(param(BAG_ID, PARAM_BOOLEAN_ID, isEqualTo(true))) + .and(param(BAG_ID, PARAM_BOOLEAN_ID, isEqualTo("true"))) .and(param(BAG_ID, PARAM_DATE_ID, isEqualTo(new Date(1354295525628L)))) + .and(param(BAG_ID, PARAM_DATE_ID, + isEqualTo(ISO8601FormatFactory.getInstance().formatDate(new Date(1354295525628L))))) .and(param(BAG_ID, PARAM_INTEGER_ID, isEqualTo(77))) // .and(param(BAG_ID, PARAM_INTEGER_ID, isIn(77))) // + .and(param(BAG_ID, PARAM_INTEGER_ID, isIn("77"))) // .and(param(BAG_ID, PARAM_INTEGER_ID, isIn(77, 88))) // .and(param(BAG_ID, PARAM_INTEGER_ID, isIn(asList(77, 88)))) // .and(param(BAG_ID, PARAM_LIST_FLOAT_ID, isEqualTo(asList(6.0D, 11.0D, 16.0D)))) .and(param(BAG_ID, PARAM_LIST_FLOAT_ID, contains(singletonList(6.0D)))) .and(param(BAG_ID, PARAM_LIST_FLOAT_ID, contains(asList(6.0D, 11.0D)))) + .and(param(BAG_ID, PARAM_LIST_FLOAT_ID, contains("6.0D,11.0D"))) .and(param(BAG_ID, PARAM_LIST_INTEGER_ID, isEqualTo(asList(5, 10, 15)))) .and(param(BAG_ID, PARAM_LIST_INTEGER_ID, contains(asList(5, 10)))) diff --git a/li.strolch.model/src/main/java/li/strolch/model/StrolchValueType.java b/li.strolch.model/src/main/java/li/strolch/model/StrolchValueType.java index df3d0264e..0bdd30e36 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/StrolchValueType.java +++ b/li.strolch.model/src/main/java/li/strolch/model/StrolchValueType.java @@ -17,24 +17,8 @@ package li.strolch.model; import java.text.MessageFormat; -import li.strolch.model.parameter.BooleanParameter; -import li.strolch.model.parameter.DateParameter; -import li.strolch.model.parameter.DurationParameter; -import li.strolch.model.parameter.FloatListParameter; -import li.strolch.model.parameter.FloatParameter; -import li.strolch.model.parameter.IntegerListParameter; -import li.strolch.model.parameter.IntegerParameter; -import li.strolch.model.parameter.LongListParameter; -import li.strolch.model.parameter.LongParameter; -import li.strolch.model.parameter.Parameter; -import li.strolch.model.parameter.StringListParameter; -import li.strolch.model.parameter.StringParameter; -import li.strolch.model.timedstate.BooleanTimedState; -import li.strolch.model.timedstate.FloatTimedState; -import li.strolch.model.timedstate.IntegerTimedState; -import li.strolch.model.timedstate.StringSetTimedState; -import li.strolch.model.timedstate.StrolchTimedState; -import li.strolch.model.timedstate.TimedState; +import li.strolch.model.parameter.*; +import li.strolch.model.timedstate.*; import li.strolch.model.timevalue.IValue; import li.strolch.model.timevalue.IValueChange; import li.strolch.model.timevalue.impl.BooleanValue; @@ -54,6 +38,11 @@ public enum StrolchValueType { * */ BOOLEAN("Boolean") { + @Override + public Object parseValue(String value) { + return BooleanParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new BooleanParameter(); @@ -85,6 +74,11 @@ public enum StrolchValueType { * */ INTEGER("Integer") { + @Override + public Object parseValue(String value) { + return IntegerParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new IntegerParameter(); @@ -116,6 +110,11 @@ public enum StrolchValueType { * */ FLOAT("Float") { + @Override + public Object parseValue(String value) { + return FloatParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new FloatParameter(); @@ -144,6 +143,11 @@ public enum StrolchValueType { * */ LONG("Long") { + @Override + public Object parseValue(String value) { + return LongParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new LongParameter(); @@ -174,6 +178,11 @@ public enum StrolchValueType { * */ STRING("String") { + @Override + public Object parseValue(String value) { + return value; + } + @Override public Parameter parameterInstance() { return new StringParameter(); @@ -204,6 +213,11 @@ public enum StrolchValueType { * */ DATE("Date") { + @Override + public Object parseValue(String value) { + return DateParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new DateParameter(); @@ -229,6 +243,11 @@ public enum StrolchValueType { * */ DURATION("Duration") { + @Override + public Object parseValue(String value) { + return DurationParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new DurationParameter(); @@ -254,6 +273,11 @@ public enum StrolchValueType { * */ FLOAT_LIST("FloatList") { + @Override + public Object parseValue(String value) { + return FloatListParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new FloatListParameter(); @@ -279,6 +303,11 @@ public enum StrolchValueType { * */ INTEGER_LIST("IntegerList") { + @Override + public Object parseValue(String value) { + return IntegerListParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new IntegerListParameter(); @@ -304,6 +333,11 @@ public enum StrolchValueType { * */ LONG_LIST("LongList") { + @Override + public Object parseValue(String value) { + return LongListParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new LongListParameter(); @@ -329,6 +363,11 @@ public enum StrolchValueType { * */ STRING_LIST("StringList") { + @Override + public Object parseValue(String value) { + return StringListParameter.parseFromString(value); + } + @Override public Parameter parameterInstance() { return new StringListParameter(); @@ -356,6 +395,12 @@ public enum StrolchValueType { * */ STRING_SET("StringSet") { + @Override + public Object parseValue(String value) { + throw new UnsupportedOperationException( + MessageFormat.format("Parsing value of type {0} is not supported!", getType())); //$NON-NLS-1$ + } + @Override public Parameter parameterInstance() { throw new UnsupportedOperationException( @@ -395,6 +440,8 @@ public enum StrolchValueType { throw new IllegalArgumentException("Type " + value + " does not exist!"); } + public abstract Object parseValue(String value); + public abstract Parameter parameterInstance(); public abstract StrolchTimedState> timedStateInstance(); diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java index 150c66557..985be8de7 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java @@ -117,4 +117,9 @@ public class BooleanParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((BooleanParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.BOOLEAN; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java index e9377daf9..5cc3053a6 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java @@ -123,4 +123,9 @@ public class DateParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((DateParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.DATE; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java index 9e37f2946..51b442cd8 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java @@ -120,4 +120,9 @@ public class DurationParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((DurationParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.DURATION; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java index 81e0eeaa8..bbf0d98fe 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java @@ -177,4 +177,9 @@ public class FloatListParameter extends AbstractParameter> implemen DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return Integer.compare(this.getValue().size(), ((FloatListParameter) o).getValue().size()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.FLOAT_LIST; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java index e0155ce9c..60e407e45 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java @@ -121,4 +121,9 @@ public class FloatParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((FloatParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.FLOAT; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java index 5de2770eb..ef2e0d819 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java @@ -177,4 +177,9 @@ public class IntegerListParameter extends AbstractParameter> imple DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return Integer.compare(this.getValue().size(), ((IntegerListParameter) o).getValue().size()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.INTEGER_LIST; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java index 99c4805f1..e94f3ce93 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java @@ -119,4 +119,9 @@ public class IntegerParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((IntegerParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.INTEGER; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java index de60e7397..8b6e276fc 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java @@ -177,4 +177,9 @@ public class LongListParameter extends AbstractParameter> implements DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return Integer.compare(this.getValue().size(), ((LongListParameter) o).getValue().size()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.LONG_LIST; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java index 74bc41b11..8889cff8b 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java @@ -119,4 +119,9 @@ public class LongParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((LongParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.LONG; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java index 917af850e..b7533920f 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java @@ -18,6 +18,7 @@ package li.strolch.model.parameter; import li.strolch.model.ParameterizedElement; import li.strolch.model.StrolchElement; import li.strolch.model.StrolchModelConstants; +import li.strolch.model.StrolchValueType; /** * @author Robert von Burg @@ -161,4 +162,9 @@ public interface Parameter extends StrolchElement, Comparable> { @Override public Parameter getClone(); + + /** + * @return the {@link StrolchValueType} + */ + public StrolchValueType getValueType(); } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java index 484b83db3..7c790c26d 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java @@ -177,4 +177,9 @@ public class StringListParameter extends AbstractParameter> impleme DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return Integer.compare(this.getValue().size(), ((StringListParameter) o).getValue().size()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.STRING_LIST; + } } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java index d3bdf0780..1f762f739 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java @@ -117,4 +117,9 @@ public class StringParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareToIgnoreCase(((StringParameter) o).getValue()); } + + @Override + public StrolchValueType getValueType() { + return StrolchValueType.STRING; + } } diff --git a/li.strolch.utils/src/main/java/li/strolch/utils/ObjectHelper.java b/li.strolch.utils/src/main/java/li/strolch/utils/ObjectHelper.java index c855cf6a6..989561e29 100644 --- a/li.strolch.utils/src/main/java/li/strolch/utils/ObjectHelper.java +++ b/li.strolch.utils/src/main/java/li/strolch/utils/ObjectHelper.java @@ -94,6 +94,10 @@ public class ObjectHelper { } } + // comparing non-strings we use equals, as contains fits as well + if (left.getClass() == right.getClass()) + return left.equals(right); + throw new IllegalArgumentException("Unhandled type combination " + left.getClass() + " / " + right.getClass()); }