You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by md...@apache.org on 2020/05/07 15:04:20 UTC
[lucene-solr] branch master updated: SOLR-14426 Move auxiliary
classes to nested classes (#1487)
This is an automated email from the ASF dual-hosted git repository.
mdrob pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucene-solr.git
The following commit(s) were added to refs/heads/master by this push:
new 31b350e SOLR-14426 Move auxiliary classes to nested classes (#1487)
31b350e is described below
commit 31b350e8040cbe30c4e85b7fb82eab4b6afd81c7
Author: Mike Drob <md...@apache.org>
AuthorDate: Thu May 7 10:04:06 2020 -0500
SOLR-14426 Move auxiliary classes to nested classes (#1487)
---
.../apache/solr/analytics/ExpressionFactory.java | 78 +-
.../apache/solr/analytics/facet/PivotFacet.java | 77 +-
.../function/mapping/ComparisonFunction.java | 320 +-
.../function/mapping/DateMathFunction.java | 171 +-
.../function/mapping/DateParseFunction.java | 261 +-
.../mapping/DecimalNumericConversionFunction.java | 281 +-
.../analytics/function/mapping/EqualFunction.java | 301 +-
.../analytics/function/mapping/ExistsFunction.java | 143 +-
.../function/mapping/FillMissingFunction.java | 1283 ++++---
.../analytics/function/mapping/FilterFunction.java | 1075 +++---
.../analytics/function/mapping/IfFunction.java | 1268 +++---
.../analytics/function/mapping/LambdaFunction.java | 4044 ++++++++++----------
.../analytics/function/mapping/RemoveFunction.java | 1187 +++---
.../function/mapping/ReplaceFunction.java | 1519 ++++----
.../analytics/function/reduction/MaxFunction.java | 405 +-
.../function/reduction/MedianFunction.java | 237 +-
.../analytics/function/reduction/MinFunction.java | 405 +-
.../function/reduction/OrdinalFunction.java | 489 +--
.../function/reduction/PercentileFunction.java | 453 +--
.../solr/analytics/util/FacetRangeGenerator.java | 132 +-
.../solr/analytics/util/MedianCalculator.java | 6 +-
.../solr/analytics/util/OrdinalCalculator.java | 15 +-
.../handler/component/SortedDateStatsValues.java | 4 +-
.../component/SortedNumericStatsValues.java | 4 +-
.../solr/handler/component/StatsValuesFactory.java | 1379 +++----
.../response/transform/DocIdAugmenterFactory.java | 31 +-
.../src/java/org/apache/solr/schema/BoolField.java | 145 +-
.../org/apache/solr/schema/DatePointField.java | 49 +-
.../org/apache/solr/search/FunctionQParser.java | 6 +-
.../org/apache/solr/search/ValueSourceParser.java | 637 ++-
.../apache/solr/search/facet/AggValueSource.java | 2 +-
.../java/org/apache/solr/search/facet/AvgAgg.java | 8 +-
.../org/apache/solr/search/facet/CountAgg.java | 2 +-
.../org/apache/solr/search/facet/CountValsAgg.java | 10 +-
.../org/apache/solr/search/facet/DocValuesAcc.java | 22 +-
.../solr/search/facet/FacetFieldProcessor.java | 8 +-
.../search/facet/FacetFieldProcessorByArray.java | 4 +-
.../search/facet/FacetFieldProcessorByArrayDV.java | 2 +-
.../facet/FacetFieldProcessorByArrayUIF.java | 2 +-
.../FacetFieldProcessorByEnumTermsStream.java | 2 +-
.../search/facet/FacetFieldProcessorByHashDV.java | 2 +-
.../org/apache/solr/search/facet/FacetModule.java | 8 +-
.../apache/solr/search/facet/FacetProcessor.java | 12 +-
.../org/apache/solr/search/facet/FacetQuery.java | 4 +-
.../org/apache/solr/search/facet/FacetRange.java | 4 +-
.../org/apache/solr/search/facet/FacetRequest.java | 1122 +++---
.../java/org/apache/solr/search/facet/HLLAgg.java | 8 +-
.../org/apache/solr/search/facet/MinMaxAgg.java | 16 +-
.../org/apache/solr/search/facet/MissingAgg.java | 4 +-
.../apache/solr/search/facet/PercentileAgg.java | 12 +-
.../apache/solr/search/facet/RelatednessAgg.java | 6 +-
.../java/org/apache/solr/search/facet/SlotAcc.java | 30 +-
.../org/apache/solr/search/facet/StddevAgg.java | 8 +-
.../java/org/apache/solr/search/facet/SumAgg.java | 8 +-
.../org/apache/solr/search/facet/SumsqAgg.java | 8 +-
.../solr/search/facet/UnInvertedFieldAcc.java | 6 +-
.../org/apache/solr/search/facet/UniqueAgg.java | 8 +-
.../apache/solr/search/facet/UniqueBlockAgg.java | 4 +-
.../solr/search/facet/UniqueBlockFieldAgg.java | 2 +-
.../solr/search/facet/UniqueBlockQueryAgg.java | 4 +-
.../solr/search/facet/UniqueMultiDvSlotAcc.java | 2 +-
.../search/facet/UniqueMultivaluedSlotAcc.java | 2 +-
.../search/facet/UniqueSinglevaluedSlotAcc.java | 2 +-
.../apache/solr/search/facet/UniqueSlotAcc.java | 2 +-
.../org/apache/solr/search/facet/VarianceAgg.java | 8 +-
.../org/apache/solr/search/facet/DebugAgg.java | 8 +-
.../solr/search/facet/TestJsonFacetRefinement.java | 2 +-
67 files changed, 8973 insertions(+), 8796 deletions(-)
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/ExpressionFactory.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/ExpressionFactory.java
index 9407d1d..1bd4334 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/ExpressionFactory.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/ExpressionFactory.java
@@ -849,43 +849,43 @@ public class ExpressionFactory {
public static interface ConstantFunction {
AnalyticsValueStream apply(String t) throws SolrException;
}
+ static class VariableFunctionInfo {
+ public String[] params;
+ public String returnSignature;
+ }
+ static class WeightedMeanVariableFunction {
+ public static final String name = "wmean";
+ public static final String params = "a,b";
+ public static final String function = DivideFunction.name+"("+SumFunction.name+"("+MultFunction.name+"(a,b)),"+SumFunction.name+"("+FilterFunction.name+"(b,"+ExistsFunction.name+"(a))))";
+ }
+ static class SumOfSquaresVariableFunction {
+ public static final String name = "sumofsquares";
+ public static final String params = "a";
+ public static final String function = SumFunction.name+"("+PowerFunction.name+"(a,2))";
+ }
+ static class SquareRootVariableFunction {
+ public static final String name = "sqrt";
+ public static final String params = "a";
+ public static final String function = PowerFunction.name+"(a,0.5)";
+ }
+ static class VarianceVariableFunction {
+ public static final String name = "variance";
+ public static final String params = "a";
+ public static final String function = SubtractFunction.name+"("+MeanFunction.name+"("+PowerFunction.name+"(a,2)),"+PowerFunction.name+"("+MeanFunction.name+"(a),2))";
+ }
+ static class SandardDeviationVariableFunction {
+ public static final String name = "stddev";
+ public static final String params = "a";
+ public static final String function = SquareRootVariableFunction.name+"("+VarianceVariableFunction.name+"(a))";
+ }
+ static class CSVVariableFunction {
+ public static final String name = "csv";
+ public static final String params = "a"+ExpressionFactory.variableLengthParamSuffix;
+ public static final String function = SeparatedConcatFunction.name+"(',',a)";
+ }
+ static class CSVOutputVariableFunction {
+ public static final String name = "csv_output";
+ public static final String params = "a"+ExpressionFactory.variableLengthParamSuffix;
+ public static final String function = "concat_sep(',',a"+ExpressionFactory.variableForEachSep+FillMissingFunction.name+"("+SeparatedConcatFunction.name+"(';',"+ExpressionFactory.variableForEachParam+"),''))";
+ }
}
-class VariableFunctionInfo {
- public String[] params;
- public String returnSignature;
-}
-class WeightedMeanVariableFunction {
- public static final String name = "wmean";
- public static final String params = "a,b";
- public static final String function = DivideFunction.name+"("+SumFunction.name+"("+MultFunction.name+"(a,b)),"+SumFunction.name+"("+FilterFunction.name+"(b,"+ExistsFunction.name+"(a))))";
-}
-class SumOfSquaresVariableFunction {
- public static final String name = "sumofsquares";
- public static final String params = "a";
- public static final String function = SumFunction.name+"("+PowerFunction.name+"(a,2))";
-}
-class SquareRootVariableFunction {
- public static final String name = "sqrt";
- public static final String params = "a";
- public static final String function = PowerFunction.name+"(a,0.5)";
-}
-class VarianceVariableFunction {
- public static final String name = "variance";
- public static final String params = "a";
- public static final String function = SubtractFunction.name+"("+MeanFunction.name+"("+PowerFunction.name+"(a,2)),"+PowerFunction.name+"("+MeanFunction.name+"(a),2))";
-}
-class SandardDeviationVariableFunction {
- public static final String name = "stddev";
- public static final String params = "a";
- public static final String function = SquareRootVariableFunction.name+"("+VarianceVariableFunction.name+"(a))";
-}
-class CSVVariableFunction {
- public static final String name = "csv";
- public static final String params = "a"+ExpressionFactory.variableLengthParamSuffix;
- public static final String function = SeparatedConcatFunction.name+"(',',a)";
-}
-class CSVOutputVariableFunction {
- public static final String name = "csv_output";
- public static final String params = "a"+ExpressionFactory.variableLengthParamSuffix;
- public static final String function = "concat_sep(',',a"+ExpressionFactory.variableForEachSep+FillMissingFunction.name+"("+SeparatedConcatFunction.name+"(';',"+ExpressionFactory.variableForEachParam+"),''))";
-}
\ No newline at end of file
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/facet/PivotFacet.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/facet/PivotFacet.java
index d06bba8..d6ff05e 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/facet/PivotFacet.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/facet/PivotFacet.java
@@ -72,43 +72,44 @@ public class PivotFacet extends AnalyticsFacet implements StreamingFacet {
public Iterable<Map<String,Object>> createResponse() {
return pivotHead.createResponse();
}
-}
-/**
- * Typed Pivot class that stores the overall Pivot data and head of the Pivot node chain.
- *
- * This class exists so that the {@link PivotFacet} class doesn't have to be typed ( {@code <T>} ).
- */
-class PivotHead<T> implements StreamingFacet {
- private final PivotNode<T> topPivot;
- private final Map<String, T> pivotValues;
-
- public PivotHead(PivotNode<T> topPivot) {
- this.topPivot = topPivot;
- this.pivotValues = new HashMap<>();
- }
-
- public void setReductionCollectionManager(ReductionCollectionManager collectionManager) {
- topPivot.setReductionCollectionManager(collectionManager);
- }
-
- public void setExpressionCalculator(ExpressionCalculator expressionCalculator) {
- topPivot.setExpressionCalculator(expressionCalculator);
- }
- @Override
- public void addFacetValueCollectionTargets() {
- topPivot.addFacetValueCollectionTargets(pivotValues);
- }
-
- public void importShardData(DataInput input) throws IOException {
- topPivot.importPivot(input, pivotValues);
- }
-
- public void exportShardData(DataOutput output) throws IOException {
- topPivot.exportPivot(output, pivotValues);
- }
-
- public Iterable<Map<String,Object>> createResponse() {
- return topPivot.getPivotedResponse(pivotValues);
+ /**
+ * Typed Pivot class that stores the overall Pivot data and head of the Pivot node chain.
+ *
+ * This class exists so that the {@link PivotFacet} class doesn't have to be typed ( {@code <T>} ).
+ */
+ private static class PivotHead<T> implements StreamingFacet {
+ private final PivotNode<T> topPivot;
+ private final Map<String, T> pivotValues;
+
+ public PivotHead(PivotNode<T> topPivot) {
+ this.topPivot = topPivot;
+ this.pivotValues = new HashMap<>();
+ }
+
+ public void setReductionCollectionManager(ReductionCollectionManager collectionManager) {
+ topPivot.setReductionCollectionManager(collectionManager);
+ }
+
+ public void setExpressionCalculator(ExpressionCalculator expressionCalculator) {
+ topPivot.setExpressionCalculator(expressionCalculator);
+ }
+
+ @Override
+ public void addFacetValueCollectionTargets() {
+ topPivot.addFacetValueCollectionTargets(pivotValues);
+ }
+
+ public void importShardData(DataInput input) throws IOException {
+ topPivot.importPivot(input, pivotValues);
+ }
+
+ public void exportShardData(DataOutput output) throws IOException {
+ topPivot.exportPivot(output, pivotValues);
+ }
+
+ public Iterable<Map<String,Object>> createResponse() {
+ return topPivot.getPivotedResponse(pivotValues);
+ }
}
-}
\ No newline at end of file
+}
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ComparisonFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ComparisonFunction.java
index 1ecc930..4b7497d 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ComparisonFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ComparisonFunction.java
@@ -17,7 +17,6 @@
package org.apache.solr.analytics.function.mapping;
import org.apache.solr.analytics.ExpressionFactory.CreatorFunction;
-import org.apache.solr.analytics.function.mapping.ComparisonFunction.CompResultFunction;
import org.apache.solr.analytics.util.function.BooleanConsumer;
import org.apache.solr.analytics.value.AnalyticsValue;
import org.apache.solr.analytics.value.AnalyticsValueStream;
@@ -141,178 +140,183 @@ public class ComparisonFunction {
private static CompResultFunction reverse(CompResultFunction original) {
return val -> original.apply(val*-1);
}
-}
-/**
- * A comparison function for two {@link DoubleValue}s.
- */
-class CompareDoubleValueFunction extends AbstractBooleanValue {
- private final DoubleValue exprA;
- private final DoubleValue exprB;
- private final CompResultFunction comp;
- private final String name;
- private final String funcStr;
- private final ExpressionType funcType;
- public CompareDoubleValueFunction(String name, DoubleValue exprA, DoubleValue exprB, CompResultFunction comp) {
- this.name = name;
- this.exprA = exprA;
- this.exprB = exprB;
- this.comp = comp;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
- }
+ /**
+ * A comparison function for two {@link DoubleValue}s.
+ */
+ static class CompareDoubleValueFunction extends AbstractBooleanValue {
+ private final DoubleValue exprA;
+ private final DoubleValue exprB;
+ private final CompResultFunction comp;
+ private final String name;
+ private final String funcStr;
+ private final ExpressionType funcType;
- private boolean exists = false;
- @Override
- public boolean getBoolean() {
- double valueA = exprA.getDouble();
- double valueB = exprB.getDouble();
- exists = exprA.exists() && exprB.exists();
- return exists ? comp.apply(Double.compare(valueA,valueB)) : false;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public CompareDoubleValueFunction(String name, DoubleValue exprA, DoubleValue exprB, CompResultFunction comp) {
+ this.name = name;
+ this.exprA = exprA;
+ this.exprB = exprB;
+ this.comp = comp;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A comparison function for a {@link DoubleValue} and a {@link DoubleValueStream}.
- */
-class CompareDoubleStreamFunction extends AbstractBooleanValueStream {
- private final DoubleValue baseExpr;
- private final DoubleValueStream compExpr;
- private final CompResultFunction comp;
- private final String name;
- private final String funcStr;
- private final ExpressionType funcType;
+ private boolean exists = false;
+ @Override
+ public boolean getBoolean() {
+ double valueA = exprA.getDouble();
+ double valueB = exprB.getDouble();
+ exists = exprA.exists() && exprB.exists();
+ return exists ? comp.apply(Double.compare(valueA,valueB)) : false;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- public CompareDoubleStreamFunction(String name, DoubleValue baseExpr, DoubleValueStream compExpr, CompResultFunction comp) throws SolrException {
- this.name = name;
- this.baseExpr = baseExpr;
- this.compExpr = compExpr;
- this.comp = comp;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- double baseValue = baseExpr.getDouble();
- if (baseExpr.exists()) {
- compExpr.streamDoubles(compValue -> cons.accept(comp.apply(Double.compare(baseValue,compValue))));
+ /**
+ * A comparison function for a {@link DoubleValue} and a {@link DoubleValueStream}.
+ */
+ static class CompareDoubleStreamFunction extends AbstractBooleanValueStream {
+ private final DoubleValue baseExpr;
+ private final DoubleValueStream compExpr;
+ private final CompResultFunction comp;
+ private final String name;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public CompareDoubleStreamFunction(String name, DoubleValue baseExpr, DoubleValueStream compExpr, CompResultFunction comp) throws SolrException {
+ this.name = name;
+ this.baseExpr = baseExpr;
+ this.compExpr = compExpr;
+ this.comp = comp;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A comparison function for two {@link DateValue}s.
- */
-class CompareDateValueFunction extends AbstractBooleanValue {
- private final DateValue exprA;
- private final DateValue exprB;
- private final CompResultFunction comp;
- private final String name;
- private final String funcStr;
- private final ExpressionType funcType;
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ double baseValue = baseExpr.getDouble();
+ if (baseExpr.exists()) {
+ compExpr.streamDoubles(compValue -> cons.accept(comp.apply(Double.compare(baseValue,compValue))));
+ }
+ }
- public CompareDateValueFunction(String name, DateValue exprA, DateValue exprB, CompResultFunction comp) {
- this.name = name;
- this.exprA = exprA;
- this.exprB = exprB;
- this.comp = comp;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- private boolean exists = false;
- @Override
- public boolean getBoolean() {
- long valueA = exprA.getLong();
- long valueB = exprB.getLong();
- exists = exprA.exists() && exprB.exists();
- return exists ? comp.apply(Long.compare(valueA,valueB)) : false;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ /**
+ * A comparison function for two {@link DateValue}s.
+ */
+ static class CompareDateValueFunction extends AbstractBooleanValue {
+ private final DateValue exprA;
+ private final DateValue exprB;
+ private final CompResultFunction comp;
+ private final String name;
+ private final String funcStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A comparison function for a {@link DateValue} and a {@link DateValueStream}.
- */
-class CompareDateStreamFunction extends AbstractBooleanValueStream {
- private final DateValue baseExpr;
- private final DateValueStream compExpr;
- private final CompResultFunction comp;
- private final String name;
- private final String funcStr;
- private final ExpressionType funcType;
+ public CompareDateValueFunction(String name, DateValue exprA, DateValue exprB, CompResultFunction comp) {
+ this.name = name;
+ this.exprA = exprA;
+ this.exprB = exprB;
+ this.comp = comp;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
+ }
- public CompareDateStreamFunction(String name, DateValue baseExpr, DateValueStream compExpr, CompResultFunction comp) throws SolrException {
- this.name = name;
- this.baseExpr = baseExpr;
- this.compExpr = compExpr;
- this.comp = comp;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
- }
+ private boolean exists = false;
+ @Override
+ public boolean getBoolean() {
+ long valueA = exprA.getLong();
+ long valueB = exprB.getLong();
+ exists = exprA.exists() && exprB.exists();
+ return exists ? comp.apply(Long.compare(valueA,valueB)) : false;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- long baseValue = baseExpr.getLong();
- if (baseExpr.exists()) {
- compExpr.streamLongs(compValue -> cons.accept(comp.apply(Long.compare(baseValue,compValue))));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ /**
+ * A comparison function for a {@link DateValue} and a {@link DateValueStream}.
+ */
+ static class CompareDateStreamFunction extends AbstractBooleanValueStream {
+ private final DateValue baseExpr;
+ private final DateValueStream compExpr;
+ private final CompResultFunction comp;
+ private final String name;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public CompareDateStreamFunction(String name, DateValue baseExpr, DateValueStream compExpr, CompResultFunction comp) throws SolrException {
+ this.name = name;
+ this.baseExpr = baseExpr;
+ this.compExpr = compExpr;
+ this.comp = comp;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
+ }
+
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ long baseValue = baseExpr.getLong();
+ if (baseExpr.exists()) {
+ compExpr.streamLongs(compValue -> cons.accept(comp.apply(Long.compare(baseValue,compValue))));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
\ No newline at end of file
+}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateMathFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateMathFunction.java
index 8a57561..93fee3e 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateMathFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateMathFunction.java
@@ -62,97 +62,100 @@ public class DateMathFunction {
throw new SolrException(ErrorCode.BAD_REQUEST,"The "+name+" function requires a date as the first parameter.");
}
});
-}
-/**
- * DateMath function that supports {@link DateValue}s.
- */
-class DateMathValueFunction extends AbstractDateValue {
- private final DateValue dateParam;
- private final String mathParam;
- DateMathParser parser = new DateMathParser();
- public static final String name = DateMathFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DateMathValueFunction(DateValue dateParam, ConstantStringValue mathParam) throws SolrException {
- this.dateParam = dateParam;
- this.mathParam = "NOW" + mathParam.getString();
- this.exprStr = AnalyticsValueStream.createExpressionString(name,dateParam,mathParam);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,dateParam);
- }
+ /**
+ * DateMath function that supports {@link DateValue}s.
+ */
+ static class DateMathValueFunction extends AbstractDateValue {
+ private final DateValue dateParam;
+ private final String mathParam;
+ DateMathParser parser = new DateMathParser();
+ public static final String name = DateMathFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- private boolean exists = false;
+ public DateMathValueFunction(DateValue dateParam, ConstantStringValue mathParam) throws SolrException {
+ this.dateParam = dateParam;
+ this.mathParam = "NOW" + mathParam.getString();
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,dateParam,mathParam);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,dateParam);
+ }
- @Override
- public long getLong() {
- Date date = getDate();
- return (exists) ? date.getTime() : 0;
- }
- @Override
- public Date getDate() {
- Date date = dateParam.getDate();
- if (dateParam.exists()) {
- exists = true;
- return DateMathParser.parseMath(date,mathParam);
- } else {
- exists = false;
- return null;
+ private boolean exists = false;
+
+ @Override
+ public long getLong() {
+ Date date = getDate();
+ return (exists) ? date.getTime() : 0;
+ }
+ @Override
+ public Date getDate() {
+ Date date = dateParam.getDate();
+ if (dateParam.exists()) {
+ exists = true;
+ return DateMathParser.parseMath(date,mathParam);
+ } else {
+ exists = false;
+ return null;
+ }
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-/**
- * DateMath function that supports {@link DateValueStream}s.
- */
-class DateMathStreamFunction extends AbstractDateValueStream {
- private final DateValueStream dateParam;
- private final String mathParam;
- public static final String name = DateMathFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DateMathStreamFunction(DateValueStream dateParam, ConstantStringValue mathParam) throws SolrException {
- this.dateParam = dateParam;
- this.mathParam = "NOW" + mathParam.getString();
- this.exprStr = AnalyticsValueStream.createExpressionString(name,dateParam,mathParam);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,dateParam);
- }
+ /**
+ * DateMath function that supports {@link DateValueStream}s.
+ */
+ static class DateMathStreamFunction extends AbstractDateValueStream {
+ private final DateValueStream dateParam;
+ private final String mathParam;
+ public static final String name = DateMathFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamLongs(LongConsumer cons) {
- streamDates(value -> cons.accept(value.getTime()));
- }
- @Override
- public void streamDates(Consumer<Date> cons) {
- dateParam.streamDates(value -> cons.accept(DateMathParser.parseMath(value, mathParam)));
- }
+ public DateMathStreamFunction(DateValueStream dateParam, ConstantStringValue mathParam) throws SolrException {
+ this.dateParam = dateParam;
+ this.mathParam = "NOW" + mathParam.getString();
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,dateParam,mathParam);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,dateParam);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ streamDates(value -> cons.accept(value.getTime()));
+ }
+ @Override
+ public void streamDates(Consumer<Date> cons) {
+ dateParam.streamDates(value -> cons.accept(DateMathParser.parseMath(value, mathParam)));
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
\ No newline at end of file
+}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateParseFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateParseFunction.java
index 83c0ba7..9462e43 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateParseFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DateParseFunction.java
@@ -61,146 +61,151 @@ public class DateParseFunction {
"Incorrect parameter: "+params[0].getExpressionStr());
}
});
-}
-class LongToDateParseFunction extends AbstractDateValue {
- private final LongValue param;
- public static final String name = DateParseFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongToDateParseFunction(LongValue param) throws SolrException {
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
- @Override
- public long getLong() {
- return param.getLong();
- }
- @Override
- public boolean exists() {
- return param.exists();
- }
+ static class LongToDateParseFunction extends AbstractDateValue {
+ private final LongValue param;
+ public static final String name = DateParseFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongStreamToDateParseFunction extends AbstractDateValueStream {
- private final LongValueStream param;
- public static final String name = DateParseFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongStreamToDateParseFunction(LongValueStream param) throws SolrException {
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ public LongToDateParseFunction(LongValue param) throws SolrException {
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- param.streamLongs(cons);
- }
+ @Override
+ public long getLong() {
+ return param.getLong();
+ }
+ @Override
+ public boolean exists() {
+ return param.exists();
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class StringToDateParseFunction extends AbstractDateValue {
- private final StringValue param;
- public static final String name = DateParseFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringToDateParseFunction(StringValue param) throws SolrException {
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- private boolean exists = false;
- @Override
- public long getLong() {
- long value = 0;
- try {
- String paramStr = param.getString();
- exists = param.exists();
- if (exists) {
- value = Instant.parse(paramStr).toEpochMilli();
- }
- } catch (DateTimeParseException e) {
- exists = false;
+ static class LongStreamToDateParseFunction extends AbstractDateValueStream {
+ private final LongValueStream param;
+ public static final String name = DateParseFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public LongStreamToDateParseFunction(LongValueStream param) throws SolrException {
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class StringStreamToDateParseFunction extends AbstractDateValueStream {
- private final StringValueStream param;
- public static final String name = DateParseFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringStreamToDateParseFunction(StringValueStream param) throws SolrException {
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ param.streamLongs(cons);
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamLongs(LongConsumer cons) {
- param.streamStrings(value -> {
+ static class StringToDateParseFunction extends AbstractDateValue {
+ private final StringValue param;
+ public static final String name = DateParseFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringToDateParseFunction(StringValue param) throws SolrException {
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ private boolean exists = false;
+ @Override
+ public long getLong() {
+ long value = 0;
try {
- cons.accept(Instant.parse(value).toEpochMilli());
- } catch (DateTimeParseException e) {}
- });
- }
+ String paramStr = param.getString();
+ exists = param.exists();
+ if (exists) {
+ value = Instant.parse(paramStr).toEpochMilli();
+ }
+ } catch (DateTimeParseException e) {
+ exists = false;
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+
+ static class StringStreamToDateParseFunction extends AbstractDateValueStream {
+ private final StringValueStream param;
+ public static final String name = DateParseFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringStreamToDateParseFunction(StringValueStream param) throws SolrException {
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ param.streamStrings(value -> {
+ try {
+ cons.accept(Instant.parse(value).toEpochMilli());
+ } catch (DateTimeParseException e) {}
+ });
+ }
+
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DecimalNumericConversionFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DecimalNumericConversionFunction.java
index c8881ee..0247da8 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DecimalNumericConversionFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/DecimalNumericConversionFunction.java
@@ -20,8 +20,6 @@ import java.util.function.IntConsumer;
import java.util.function.LongConsumer;
import org.apache.solr.analytics.ExpressionFactory.CreatorFunction;
-import org.apache.solr.analytics.function.mapping.DecimalNumericConversionFunction.ConvertDoubleFunction;
-import org.apache.solr.analytics.function.mapping.DecimalNumericConversionFunction.ConvertFloatFunction;
import org.apache.solr.analytics.value.AnalyticsValueStream;
import org.apache.solr.analytics.value.DoubleValue;
import org.apache.solr.analytics.value.DoubleValueStream;
@@ -116,156 +114,161 @@ public class DecimalNumericConversionFunction {
public static interface ConvertDoubleFunction {
public long convert(double value);
}
-}
-/**
- * A function to convert a {@link FloatValue} to a {@link IntValue}.
- */
-class ConvertFloatValueFunction extends AbstractIntValue {
- private final String name;
- private final FloatValue param;
- private final ConvertFloatFunction conv;
- private final String funcStr;
- private final ExpressionType funcType;
- public ConvertFloatValueFunction(String name, FloatValue param, ConvertFloatFunction conv) {
- this.name = name;
- this.param = param;
- this.conv = conv;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
- }
+ /**
+ * A function to convert a {@link FloatValue} to a {@link IntValue}.
+ */
+ static class ConvertFloatValueFunction extends AbstractIntValue {
+ private final String name;
+ private final FloatValue param;
+ private final ConvertFloatFunction conv;
+ private final String funcStr;
+ private final ExpressionType funcType;
- @Override
- public int getInt() {
- return conv.convert(param.getFloat());
- }
- @Override
- public boolean exists() {
- return param.exists();
- }
+ public ConvertFloatValueFunction(String name, FloatValue param, ConvertFloatFunction conv) {
+ this.name = name;
+ this.param = param;
+ this.conv = conv;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A function to convert a {@link FloatValueStream} to a {@link IntValueStream}.
- */
-class ConvertFloatStreamFunction extends AbstractIntValueStream {
- private final String name;
- private final FloatValueStream param;
- private final ConvertFloatFunction conv;
- private final String funcStr;
- private final ExpressionType funcType;
+ @Override
+ public int getInt() {
+ return conv.convert(param.getFloat());
+ }
+ @Override
+ public boolean exists() {
+ return param.exists();
+ }
- public ConvertFloatStreamFunction(String name, FloatValueStream param, ConvertFloatFunction conv) {
- this.name = name;
- this.param = param;
- this.conv = conv;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamInts(IntConsumer cons) {
- param.streamFloats( value -> cons.accept(conv.convert(value)));
- }
+ /**
+ * A function to convert a {@link FloatValueStream} to a {@link IntValueStream}.
+ */
+ static class ConvertFloatStreamFunction extends AbstractIntValueStream {
+ private final String name;
+ private final FloatValueStream param;
+ private final ConvertFloatFunction conv;
+ private final String funcStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A function to convert a {@link DoubleValue} to a {@link LongValue}.
- */
-class ConvertDoubleValueFunction extends AbstractLongValue {
- private final String name;
- private final DoubleValue param;
- private final ConvertDoubleFunction conv;
- private final String funcStr;
- private final ExpressionType funcType;
+ public ConvertFloatStreamFunction(String name, FloatValueStream param, ConvertFloatFunction conv) {
+ this.name = name;
+ this.param = param;
+ this.conv = conv;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
+ }
- public ConvertDoubleValueFunction(String name, DoubleValue param, ConvertDoubleFunction conv) {
- this.name = name;
- this.param = param;
- this.conv = conv;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
- }
+ @Override
+ public void streamInts(IntConsumer cons) {
+ param.streamFloats( value -> cons.accept(conv.convert(value)));
+ }
- @Override
- public long getLong() {
- return conv.convert(param.getDouble());
- }
- @Override
- public boolean exists() {
- return param.exists();
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A function to convert a {@link DoubleValueStream} to a {@link LongValueStream}.
- */
-class ConvertDoubleStreamFunction extends AbstractLongValueStream {
- private final String name;
- private final DoubleValueStream param;
- private final ConvertDoubleFunction conv;
- private final String funcStr;
- private final ExpressionType funcType;
+ /**
+ * A function to convert a {@link DoubleValue} to a {@link LongValue}.
+ */
+ static class ConvertDoubleValueFunction extends AbstractLongValue {
+ private final String name;
+ private final DoubleValue param;
+ private final ConvertDoubleFunction conv;
+ private final String funcStr;
+ private final ExpressionType funcType;
- public ConvertDoubleStreamFunction(String name, DoubleValueStream param, ConvertDoubleFunction conv) {
- this.name = name;
- this.param = param;
- this.conv = conv;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
- }
+ public ConvertDoubleValueFunction(String name, DoubleValue param, ConvertDoubleFunction conv) {
+ this.name = name;
+ this.param = param;
+ this.conv = conv;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- param.streamDoubles( value -> cons.accept(conv.convert(value)));
- }
+ @Override
+ public long getLong() {
+ return conv.convert(param.getDouble());
+ }
+ @Override
+ public boolean exists() {
+ return param.exists();
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+
+ /**
+ * A function to convert a {@link DoubleValueStream} to a {@link LongValueStream}.
+ */
+ static class ConvertDoubleStreamFunction extends AbstractLongValueStream {
+ private final String name;
+ private final DoubleValueStream param;
+ private final ConvertDoubleFunction conv;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public ConvertDoubleStreamFunction(String name, DoubleValueStream param, ConvertDoubleFunction conv) {
+ this.name = name;
+ this.param = param;
+ this.conv = conv;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,param);
+ }
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ param.streamDoubles( value -> cons.accept(conv.convert(value)));
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
\ No newline at end of file
+}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/EqualFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/EqualFunction.java
index 18a8bce..9d1bbf2 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/EqualFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/EqualFunction.java
@@ -73,166 +73,171 @@ public class EqualFunction {
}
throw new SolrException(ErrorCode.BAD_REQUEST,"The "+name+" function requires that at least 1 parameter be single-valued.");
});
-}
-/**
- * An equal function for two {@link BooleanValue}s.
- */
-class BooleanValueEqualFunction extends AbstractBooleanValue {
- private final BooleanValue exprA;
- private final BooleanValue exprB;
- public static final String name = EqualFunction.name;
- private final String funcStr;
- private final ExpressionType funcType;
-
- public BooleanValueEqualFunction(BooleanValue exprA, BooleanValue exprB) {
- this.exprA = exprA;
- this.exprB = exprB;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
- }
- private boolean exists = false;
- @Override
- public boolean getBoolean() {
- boolean valueA = exprA.getBoolean();
- boolean valueB = exprB.getBoolean();
- exists = exprA.exists() && exprB.exists();
- return exists ? valueA == valueB : false;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ /**
+ * An equal function for two {@link BooleanValue}s.
+ */
+ static class BooleanValueEqualFunction extends AbstractBooleanValue {
+ private final BooleanValue exprA;
+ private final BooleanValue exprB;
+ public static final String name = EqualFunction.name;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public BooleanValueEqualFunction(BooleanValue exprA, BooleanValue exprB) {
+ this.exprA = exprA;
+ this.exprB = exprB;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * An equal function for a {@link BooleanValue} and a {@link BooleanValueStream}.
- */
-class BooleanStreamEqualFunction extends AbstractBooleanValueStream {
- private final BooleanValue baseExpr;
- private final BooleanValueStream compExpr;
- public static final String name = EqualFunction.name;
- private final String funcStr;
- private final ExpressionType funcType;
-
- public BooleanStreamEqualFunction(BooleanValue baseExpr, BooleanValueStream compExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.compExpr = compExpr;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
- }
+ private boolean exists = false;
+ @Override
+ public boolean getBoolean() {
+ boolean valueA = exprA.getBoolean();
+ boolean valueB = exprB.getBoolean();
+ exists = exprA.exists() && exprB.exists();
+ return exists ? valueA == valueB : false;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- boolean baseValue = baseExpr.getBoolean();
- if (baseExpr.exists()) {
- compExpr.streamBooleans(compValue -> cons.accept(baseValue == compValue));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A catch-all equal function for two {@link AnalyticsValue}s.
- */
-class ValueEqualFunction extends AbstractBooleanValue {
- private final AnalyticsValue exprA;
- private final AnalyticsValue exprB;
- public static final String name = EqualFunction.name;
- private final String funcStr;
- private final ExpressionType funcType;
-
- public ValueEqualFunction(AnalyticsValue exprA, AnalyticsValue exprB) {
- this.exprA = exprA;
- this.exprB = exprB;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
- }
+ /**
+ * An equal function for a {@link BooleanValue} and a {@link BooleanValueStream}.
+ */
+ static class BooleanStreamEqualFunction extends AbstractBooleanValueStream {
+ private final BooleanValue baseExpr;
+ private final BooleanValueStream compExpr;
+ public static final String name = EqualFunction.name;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public BooleanStreamEqualFunction(BooleanValue baseExpr, BooleanValueStream compExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.compExpr = compExpr;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
+ }
- private boolean exists = false;
- @Override
- public boolean getBoolean() {
- Object valueA = exprA.getObject();
- Object valueB = exprB.getObject();
- exists = exprA.exists() && exprB.exists();
- return exists ? valueA.equals(valueB) : false;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ boolean baseValue = baseExpr.getBoolean();
+ if (baseExpr.exists()) {
+ compExpr.streamBooleans(compValue -> cons.accept(baseValue == compValue));
+ }
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * A catch-all equal function for an {@link AnalyticsValue} and an {@link AnalyticsValueStream}.
- */
-class StreamEqualFunction extends AbstractBooleanValueStream {
- private final AnalyticsValue baseExpr;
- private final AnalyticsValueStream compExpr;
- public static final String name = EqualFunction.name;
- private final String funcStr;
- private final ExpressionType funcType;
-
- public StreamEqualFunction(AnalyticsValue baseExpr, AnalyticsValueStream compExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.compExpr = compExpr;
- this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- Object baseValue = baseExpr.getObject();
- if (baseExpr.exists()) {
- compExpr.streamObjects(compValue -> cons.accept(baseValue.equals(compValue)));
+ /**
+ * A catch-all equal function for two {@link AnalyticsValue}s.
+ */
+ static class ValueEqualFunction extends AbstractBooleanValue {
+ private final AnalyticsValue exprA;
+ private final AnalyticsValue exprB;
+ public static final String name = EqualFunction.name;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public ValueEqualFunction(AnalyticsValue exprA, AnalyticsValue exprB) {
+ this.exprA = exprA;
+ this.exprB = exprB;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,exprA,exprB);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,exprA,exprB);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return funcStr;
+ private boolean exists = false;
+ @Override
+ public boolean getBoolean() {
+ Object valueA = exprA.getObject();
+ Object valueB = exprB.getObject();
+ exists = exprA.exists() && exprB.exists();
+ return exists ? valueA.equals(valueB) : false;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+
+ /**
+ * A catch-all equal function for an {@link AnalyticsValue} and an {@link AnalyticsValueStream}.
+ */
+ static class StreamEqualFunction extends AbstractBooleanValueStream {
+ private final AnalyticsValue baseExpr;
+ private final AnalyticsValueStream compExpr;
+ public static final String name = EqualFunction.name;
+ private final String funcStr;
+ private final ExpressionType funcType;
+
+ public StreamEqualFunction(AnalyticsValue baseExpr, AnalyticsValueStream compExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.compExpr = compExpr;
+ this.funcStr = AnalyticsValueStream.createExpressionString(name,baseExpr,compExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(funcStr,baseExpr,compExpr);
+ }
+
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ Object baseValue = baseExpr.getObject();
+ if (baseExpr.exists()) {
+ compExpr.streamObjects(compValue -> cons.accept(baseValue.equals(compValue)));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return funcStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ExistsFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ExistsFunction.java
index 0e28917..44f571d 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ExistsFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/ExistsFunction.java
@@ -42,82 +42,85 @@ public class ExistsFunction {
}
return new ValueStreamExistsFunction(param);
});
-}
-/**
- * Exists function that supports {@link AnalyticsValueStream}s.
- */
-class ValueStreamExistsFunction extends AbstractBooleanValue {
- private final AnalyticsValueStream param;
- public static final String name = ExistsFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public ValueStreamExistsFunction(AnalyticsValueStream param) throws SolrException {
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ /**
+ * Exists function that supports {@link AnalyticsValueStream}s.
+ */
+ static class ValueStreamExistsFunction extends AbstractBooleanValue {
+ private final AnalyticsValueStream param;
+ public static final String name = ExistsFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- private boolean exists;
- @Override
- public boolean getBoolean() {
- exists = false;
- param.streamObjects(val -> exists = true);
- return exists;
- }
- @Override
- public boolean exists() {
- return true;
- }
+ public ValueStreamExistsFunction(AnalyticsValueStream param) throws SolrException {
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-/**
- * Exists function that supports {@link AnalyticsValue}s.
- */
-class ValueExistsFunction extends AbstractBooleanValue {
- private final AnalyticsValue param;
- public static final String name = ExistsFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
+ private boolean exists;
+ @Override
+ public boolean getBoolean() {
+ exists = false;
+ param.streamObjects(val -> exists = true);
+ return exists;
+ }
+ @Override
+ public boolean exists() {
+ return true;
+ }
- public ValueExistsFunction(AnalyticsValue param) throws SolrException {
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public boolean getBoolean() {
- param.getObject();
- return param.exists();
- }
- @Override
- public boolean exists() {
- return true;
- }
+ /**
+ * Exists function that supports {@link AnalyticsValue}s.
+ */
+ static class ValueExistsFunction extends AbstractBooleanValue {
+ private final AnalyticsValue param;
+ public static final String name = ExistsFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ public ValueExistsFunction(AnalyticsValue param) throws SolrException {
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ @Override
+ public boolean getBoolean() {
+ param.getObject();
+ return param.exists();
+ }
+ @Override
+ public boolean exists() {
+ return true;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FillMissingFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FillMissingFunction.java
index 7bc38fd..592fc1a 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FillMissingFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FillMissingFunction.java
@@ -128,716 +128,733 @@ public class FillMissingFunction {
}
return new StreamFillMissingFunction(baseExpr,fillExpr);
});
-}
-class StreamFillMissingFunction extends AbstractAnalyticsValueStream implements Consumer<Object> {
- private final AnalyticsValueStream baseExpr;
- private final AnalyticsValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StreamFillMissingFunction(AnalyticsValueStream baseExpr, AnalyticsValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
- boolean exists = false;
- Consumer<Object> cons;
+ static class StreamFillMissingFunction extends AbstractAnalyticsValueStream implements Consumer<Object> {
+ private final AnalyticsValueStream baseExpr;
+ private final AnalyticsValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamObjects(Consumer<Object> cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamObjects(this);
- if (!exists) {
- fillExpr.streamObjects(cons);
+ public StreamFillMissingFunction(AnalyticsValueStream baseExpr, AnalyticsValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
}
- }
- @Override
- public void accept(Object value) {
- exists = true;
- cons.accept(value);
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class ValueFillMissingFunction extends AbstractAnalyticsValue {
- private final AnalyticsValue baseExpr;
- private final AnalyticsValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public ValueFillMissingFunction(AnalyticsValue baseExpr, AnalyticsValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ boolean exists = false;
+ Consumer<Object> cons;
- boolean exists = false;
+ @Override
+ public void streamObjects(Consumer<Object> cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamObjects(this);
+ if (!exists) {
+ fillExpr.streamObjects(cons);
+ }
+ }
+ @Override
+ public void accept(Object value) {
+ exists = true;
+ cons.accept(value);
+ }
- @Override
- public Object getObject() {
- Object value = baseExpr.getObject();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getObject();
- exists = fillExpr.exists();
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanStreamFillMissingFunction extends AbstractBooleanValueStream implements BooleanConsumer {
- private final BooleanValueStream baseExpr;
- private final BooleanValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public BooleanStreamFillMissingFunction(BooleanValueStream baseExpr, BooleanValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ static class ValueFillMissingFunction extends AbstractAnalyticsValue {
+ private final AnalyticsValue baseExpr;
+ private final AnalyticsValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public ValueFillMissingFunction(AnalyticsValue baseExpr, AnalyticsValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
- boolean exists = false;
- BooleanConsumer cons;
+ boolean exists = false;
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamBooleans(this);
- if (!exists) {
- fillExpr.streamBooleans(cons);
+ @Override
+ public Object getObject() {
+ Object value = baseExpr.getObject();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getObject();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public void accept(boolean value) {
- exists = true;
- cons.accept(value);
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanFillMissingFunction extends AbstractBooleanValue {
- private final BooleanValue baseExpr;
- private final BooleanValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public BooleanFillMissingFunction(BooleanValue baseExpr, BooleanValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class BooleanStreamFillMissingFunction extends AbstractBooleanValueStream implements BooleanConsumer {
+ private final BooleanValueStream baseExpr;
+ private final BooleanValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public boolean getBoolean() {
- boolean value = baseExpr.getBoolean();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getBoolean();
- exists = fillExpr.exists();
+ public BooleanStreamFillMissingFunction(BooleanValueStream baseExpr, BooleanValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntStreamFillMissingFunction extends AbstractIntValueStream implements IntConsumer {
- private final IntValueStream baseExpr;
- private final IntValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public IntStreamFillMissingFunction(IntValueStream baseExpr, IntValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ boolean exists = false;
+ BooleanConsumer cons;
- boolean exists = false;
- IntConsumer cons;
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamBooleans(this);
+ if (!exists) {
+ fillExpr.streamBooleans(cons);
+ }
+ }
+ @Override
+ public void accept(boolean value) {
+ exists = true;
+ cons.accept(value);
+ }
- @Override
- public void streamInts(IntConsumer cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamInts(this);
- if (!exists) {
- fillExpr.streamInts(cons);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- }
- @Override
- public void accept(int value) {
- exists = true;
- cons.accept(value);
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntFillMissingFunction extends AbstractIntValue {
- private final IntValue baseExpr;
- private final IntValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public IntFillMissingFunction(IntValue baseExpr, IntValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ static class BooleanFillMissingFunction extends AbstractBooleanValue {
+ private final BooleanValue baseExpr;
+ private final BooleanValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public BooleanFillMissingFunction(BooleanValue baseExpr, BooleanValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
- boolean exists = false;
+ boolean exists = false;
- @Override
- public int getInt() {
- int value = baseExpr.getInt();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getInt();
- exists = fillExpr.exists();
+ @Override
+ public boolean getBoolean() {
+ boolean value = baseExpr.getBoolean();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getBoolean();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongStreamFillMissingFunction extends AbstractLongValueStream implements LongConsumer {
- private final LongValueStream baseExpr;
- private final LongValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongStreamFillMissingFunction(LongValueStream baseExpr, LongValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
- LongConsumer cons;
+ static class IntStreamFillMissingFunction extends AbstractIntValueStream implements IntConsumer {
+ private final IntValueStream baseExpr;
+ private final IntValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamLongs(LongConsumer cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamLongs(this);
- if (!exists) {
- fillExpr.streamLongs(cons);
+ public IntStreamFillMissingFunction(IntValueStream baseExpr, IntValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
}
- }
- @Override
- public void accept(long value) {
- exists = true;
- cons.accept(value);
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongFillMissingFunction extends AbstractLongValue {
- private final LongValue baseExpr;
- private final LongValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongFillMissingFunction(LongValue baseExpr, LongValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ boolean exists = false;
+ IntConsumer cons;
- boolean exists = false;
+ @Override
+ public void streamInts(IntConsumer cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamInts(this);
+ if (!exists) {
+ fillExpr.streamInts(cons);
+ }
+ }
+ @Override
+ public void accept(int value) {
+ exists = true;
+ cons.accept(value);
+ }
- @Override
- public long getLong() {
- long value = baseExpr.getLong();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getLong();
- exists = fillExpr.exists();
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatStreamFillMissingFunction extends AbstractFloatValueStream implements FloatConsumer {
- private final FloatValueStream baseExpr;
- private final FloatValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public FloatStreamFillMissingFunction(FloatValueStream baseExpr, FloatValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ static class IntFillMissingFunction extends AbstractIntValue {
+ private final IntValue baseExpr;
+ private final IntValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public IntFillMissingFunction(IntValue baseExpr, IntValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
- boolean exists = false;
- FloatConsumer cons;
+ boolean exists = false;
- @Override
- public void streamFloats(FloatConsumer cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamFloats(this);
- if (!exists) {
- fillExpr.streamFloats(cons);
+ @Override
+ public int getInt() {
+ int value = baseExpr.getInt();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getInt();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public void accept(float value) {
- exists = true;
- cons.accept(value);
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatFillMissingFunction extends AbstractFloatValue {
- private final FloatValue baseExpr;
- private final FloatValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public FloatFillMissingFunction(FloatValue baseExpr, FloatValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class LongStreamFillMissingFunction extends AbstractLongValueStream implements LongConsumer {
+ private final LongValueStream baseExpr;
+ private final LongValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public float getFloat() {
- float value = baseExpr.getFloat();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getFloat();
- exists = fillExpr.exists();
+ public LongStreamFillMissingFunction(LongValueStream baseExpr, LongValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleStreamFillMissingFunction extends AbstractDoubleValueStream implements DoubleConsumer {
- private final DoubleValueStream baseExpr;
- private final DoubleValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DoubleStreamFillMissingFunction(DoubleValueStream baseExpr, DoubleValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ boolean exists = false;
+ LongConsumer cons;
- boolean exists = false;
- DoubleConsumer cons;
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamLongs(this);
+ if (!exists) {
+ fillExpr.streamLongs(cons);
+ }
+ }
+ @Override
+ public void accept(long value) {
+ exists = true;
+ cons.accept(value);
+ }
- @Override
- public void streamDoubles(DoubleConsumer cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamDoubles(this);
- if (!exists) {
- fillExpr.streamDoubles(cons);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- }
- @Override
- public void accept(double value) {
- exists = true;
- cons.accept(value);
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleFillMissingFunction extends AbstractDoubleValue {
- private final DoubleValue baseExpr;
- private final DoubleValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DoubleFillMissingFunction(DoubleValue baseExpr, DoubleValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ static class LongFillMissingFunction extends AbstractLongValue {
+ private final LongValue baseExpr;
+ private final LongValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public LongFillMissingFunction(LongValue baseExpr, LongValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
- boolean exists = false;
+ boolean exists = false;
- @Override
- public double getDouble() {
- double value = baseExpr.getDouble();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getDouble();
- exists = fillExpr.exists();
+ @Override
+ public long getLong() {
+ long value = baseExpr.getLong();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getLong();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateStreamFillMissingFunction extends AbstractDateValueStream implements LongConsumer {
- private final DateValueStream baseExpr;
- private final DateValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DateStreamFillMissingFunction(DateValueStream baseExpr, DateValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
- LongConsumer cons;
+ static class FloatStreamFillMissingFunction extends AbstractFloatValueStream implements FloatConsumer {
+ private final FloatValueStream baseExpr;
+ private final FloatValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamLongs(LongConsumer cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamLongs(this);
- if (!exists) {
- fillExpr.streamLongs(cons);
+ public FloatStreamFillMissingFunction(FloatValueStream baseExpr, FloatValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
}
- }
- @Override
- public void accept(long value) {
- exists = true;
- cons.accept(value);
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateFillMissingFunction extends AbstractDateValue {
- private final DateValue baseExpr;
- private final DateValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DateFillMissingFunction(DateValue baseExpr, DateValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ boolean exists = false;
+ FloatConsumer cons;
- boolean exists = false;
+ @Override
+ public void streamFloats(FloatConsumer cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamFloats(this);
+ if (!exists) {
+ fillExpr.streamFloats(cons);
+ }
+ }
+ @Override
+ public void accept(float value) {
+ exists = true;
+ cons.accept(value);
+ }
- @Override
- public long getLong() {
- long value = baseExpr.getLong();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getLong();
- exists = fillExpr.exists();
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class StringStreamFillMissingFunction extends AbstractStringValueStream implements Consumer<String> {
- private final StringValueStream baseExpr;
- private final StringValueStream fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringStreamFillMissingFunction(StringValueStream baseExpr, StringValueStream fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
- }
+ static class FloatFillMissingFunction extends AbstractFloatValue {
+ private final FloatValue baseExpr;
+ private final FloatValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- boolean exists = false;
- Consumer<String> cons;
+ public FloatFillMissingFunction(FloatValue baseExpr, FloatValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
- @Override
- public void streamStrings(Consumer<String> cons) {
- exists = false;
- this.cons = cons;
- baseExpr.streamStrings(this);
- if (!exists) {
- fillExpr.streamStrings(cons);
+ boolean exists = false;
+
+ @Override
+ public float getFloat() {
+ float value = baseExpr.getFloat();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getFloat();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public void accept(String value) {
- exists = true;
- cons.accept(value);
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class StringFillMissingFunction extends AbstractStringValue {
- private final StringValue baseExpr;
- private final StringValue fillExpr;
- public static final String name = FillMissingFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringFillMissingFunction(StringValue baseExpr, StringValue fillExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.fillExpr = fillExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+
+ static class DoubleStreamFillMissingFunction extends AbstractDoubleValueStream implements DoubleConsumer {
+ private final DoubleValueStream baseExpr;
+ private final DoubleValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DoubleStreamFillMissingFunction(DoubleValueStream baseExpr, DoubleValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
+
+ boolean exists = false;
+ DoubleConsumer cons;
+
+ @Override
+ public void streamDoubles(DoubleConsumer cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamDoubles(this);
+ if (!exists) {
+ fillExpr.streamDoubles(cons);
+ }
+ }
+ @Override
+ public void accept(double value) {
+ exists = true;
+ cons.accept(value);
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class DoubleFillMissingFunction extends AbstractDoubleValue {
+ private final DoubleValue baseExpr;
+ private final DoubleValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getString() {
- String value = baseExpr.getString();
- exists = true;
- if (!baseExpr.exists()) {
- value = fillExpr.getString();
- exists = fillExpr.exists();
+ public DoubleFillMissingFunction(DoubleValue baseExpr, DoubleValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public double getDouble() {
+ double value = baseExpr.getDouble();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getDouble();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
}
- @Override
- public boolean exists() {
- return exists;
+
+ static class DateStreamFillMissingFunction extends AbstractDateValueStream implements LongConsumer {
+ private final DateValueStream baseExpr;
+ private final DateValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateStreamFillMissingFunction(DateValueStream baseExpr, DateValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
+
+ boolean exists = false;
+ LongConsumer cons;
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamLongs(this);
+ if (!exists) {
+ fillExpr.streamLongs(cons);
+ }
+ }
+ @Override
+ public void accept(long value) {
+ exists = true;
+ cons.accept(value);
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
+ static class DateFillMissingFunction extends AbstractDateValue {
+ private final DateValue baseExpr;
+ private final DateValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateFillMissingFunction(DateValue baseExpr, DateValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public long getLong() {
+ long value = baseExpr.getLong();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getLong();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getExpressionStr() {
- return exprStr;
+
+ static class StringStreamFillMissingFunction extends AbstractStringValueStream implements Consumer<String> {
+ private final StringValueStream baseExpr;
+ private final StringValueStream fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringStreamFillMissingFunction(StringValueStream baseExpr, StringValueStream fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
+
+ boolean exists = false;
+ Consumer<String> cons;
+
+ @Override
+ public void streamStrings(Consumer<String> cons) {
+ exists = false;
+ this.cons = cons;
+ baseExpr.streamStrings(this);
+ if (!exists) {
+ fillExpr.streamStrings(cons);
+ }
+ }
+ @Override
+ public void accept(String value) {
+ exists = true;
+ cons.accept(value);
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+
+ static class StringFillMissingFunction extends AbstractStringValue {
+ private final StringValue baseExpr;
+ private final StringValue fillExpr;
+ public static final String name = FillMissingFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringFillMissingFunction(StringValue baseExpr, StringValue fillExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.fillExpr = fillExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,fillExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,fillExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public String getString() {
+ String value = baseExpr.getString();
+ exists = true;
+ if (!baseExpr.exists()) {
+ value = fillExpr.getString();
+ exists = fillExpr.exists();
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
\ No newline at end of file
+}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FilterFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FilterFunction.java
index 6dac746..f266e79 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FilterFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/FilterFunction.java
@@ -128,596 +128,613 @@ public class FilterFunction {
}
return new StreamFilterFunction(baseExpr,filterExpr);
});
-}
-class StreamFilterFunction extends AbstractAnalyticsValueStream {
- private final AnalyticsValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StreamFilterFunction(AnalyticsValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
- @Override
- public void streamObjects(Consumer<Object> cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamObjects(cons);
+ static class StreamFilterFunction extends AbstractAnalyticsValueStream {
+ private final AnalyticsValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StreamFilterFunction(AnalyticsValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class ValueFilterFunction extends AbstractAnalyticsValue {
- private final AnalyticsValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public ValueFilterFunction(AnalyticsValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ @Override
+ public void streamObjects(Consumer<Object> cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamObjects(cons);
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class ValueFilterFunction extends AbstractAnalyticsValue {
+ private final AnalyticsValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public Object getObject() {
- Object value = baseExpr.getObject();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public ValueFilterFunction(AnalyticsValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanStreamFilterFunction extends AbstractBooleanValueStream {
- private final BooleanValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public BooleanStreamFilterFunction(BooleanValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ boolean exists = false;
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamBooleans(cons);
+ @Override
+ public Object getObject() {
+ Object value = baseExpr.getObject();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanFilterFunction extends AbstractBooleanValue {
- private final BooleanValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public BooleanFilterFunction(BooleanValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class BooleanStreamFilterFunction extends AbstractBooleanValueStream {
+ private final BooleanValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public boolean getBoolean() {
- boolean value = baseExpr.getBoolean();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public BooleanStreamFilterFunction(BooleanValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntStreamFilterFunction extends AbstractIntValueStream {
- private final IntValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public IntStreamFilterFunction(IntValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamBooleans(cons);
+ }
+ }
- @Override
- public void streamInts(IntConsumer cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamInts(cons);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntFilterFunction extends AbstractIntValue {
- private final IntValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public IntFilterFunction(IntValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ static class BooleanFilterFunction extends AbstractBooleanValue {
+ private final BooleanValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- boolean exists = false;
+ public BooleanFilterFunction(BooleanValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
- @Override
- public int getInt() {
- int value = baseExpr.getInt();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ boolean exists = false;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongStreamFilterFunction extends AbstractLongValueStream {
- private final LongValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongStreamFilterFunction(LongValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ @Override
+ public boolean getBoolean() {
+ boolean value = baseExpr.getBoolean();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamLongs(cons);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongFilterFunction extends AbstractLongValue {
- private final LongValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongFilterFunction(LongValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ static class IntStreamFilterFunction extends AbstractIntValueStream {
+ private final IntValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- boolean exists = false;
+ public IntStreamFilterFunction(IntValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
- @Override
- public long getLong() {
- long value = baseExpr.getLong();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ @Override
+ public void streamInts(IntConsumer cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamInts(cons);
+ }
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatStreamFilterFunction extends AbstractFloatValueStream {
- private final FloatValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public FloatStreamFilterFunction(FloatValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamFloats(FloatConsumer cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamFloats(cons);
+ static class IntFilterFunction extends AbstractIntValue {
+ private final IntValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public IntFilterFunction(IntValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatFilterFunction extends AbstractFloatValue {
- private final FloatValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public FloatFilterFunction(FloatValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ boolean exists = false;
- boolean exists = false;
+ @Override
+ public int getInt() {
+ int value = baseExpr.getInt();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public float getFloat() {
- float value = baseExpr.getFloat();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleStreamFilterFunction extends AbstractDoubleValueStream {
- private final DoubleValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DoubleStreamFilterFunction(DoubleValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ static class LongStreamFilterFunction extends AbstractLongValueStream {
+ private final LongValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamDoubles(DoubleConsumer cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamDoubles(cons);
+ public LongStreamFilterFunction(LongValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleFilterFunction extends AbstractDoubleValue {
- private final DoubleValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DoubleFilterFunction(DoubleValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamLongs(cons);
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class LongFilterFunction extends AbstractLongValue {
+ private final LongValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public double getDouble() {
- double value = baseExpr.getDouble();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public LongFilterFunction(LongValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateStreamFilterFunction extends AbstractDateValueStream {
- private final DateValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DateStreamFilterFunction(DateValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ boolean exists = false;
- @Override
- public void streamLongs(LongConsumer cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamLongs(cons);
+ @Override
+ public long getLong() {
+ long value = baseExpr.getLong();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateFilterFunction extends AbstractDateValue {
- private final DateValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DateFilterFunction(DateValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class FloatStreamFilterFunction extends AbstractFloatValueStream {
+ private final FloatValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public long getLong() {
- long value = baseExpr.getLong();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public FloatStreamFilterFunction(FloatValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class StringStreamFilterFunction extends AbstractStringValueStream {
- private final StringValueStream baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringStreamFilterFunction(StringValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
- }
+ @Override
+ public void streamFloats(FloatConsumer cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamFloats(cons);
+ }
+ }
- @Override
- public void streamStrings(Consumer<String> cons) {
- if (filterExpr.getBoolean() && filterExpr.exists()) {
- baseExpr.streamStrings(cons);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ static class FloatFilterFunction extends AbstractFloatValue {
+ private final FloatValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public FloatFilterFunction(FloatValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public float getFloat() {
+ float value = baseExpr.getFloat();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class StringFilterFunction extends AbstractStringValue {
- private final StringValue baseExpr;
- private final BooleanValue filterExpr;
- public static final String name = FilterFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringFilterFunction(StringValue baseExpr, BooleanValue filterExpr) throws SolrException {
- this.baseExpr = baseExpr;
- this.filterExpr = filterExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+
+ static class DoubleStreamFilterFunction extends AbstractDoubleValueStream {
+ private final DoubleValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DoubleStreamFilterFunction(DoubleValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ @Override
+ public void streamDoubles(DoubleConsumer cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamDoubles(cons);
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- boolean exists = false;
+ static class DoubleFilterFunction extends AbstractDoubleValue {
+ private final DoubleValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getString() {
- String value = baseExpr.getString();
- exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
- return value;
+ public DoubleFilterFunction(DoubleValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public double getDouble() {
+ double value = baseExpr.getDouble();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public boolean exists() {
- return exists;
+
+ static class DateStreamFilterFunction extends AbstractDateValueStream {
+ private final DateValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateStreamFilterFunction(DateValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamLongs(cons);
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
+ static class DateFilterFunction extends AbstractDateValue {
+ private final DateValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateFilterFunction(DateValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public long getLong() {
+ long value = baseExpr.getLong();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getExpressionStr() {
- return exprStr;
+
+ static class StringStreamFilterFunction extends AbstractStringValueStream {
+ private final StringValueStream baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringStreamFilterFunction(StringValueStream baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ @Override
+ public void streamStrings(Consumer<String> cons) {
+ if (filterExpr.getBoolean() && filterExpr.exists()) {
+ baseExpr.streamStrings(cons);
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+
+ static class StringFilterFunction extends AbstractStringValue {
+ private final StringValue baseExpr;
+ private final BooleanValue filterExpr;
+ public static final String name = FilterFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringFilterFunction(StringValue baseExpr, BooleanValue filterExpr) throws SolrException {
+ this.baseExpr = baseExpr;
+ this.filterExpr = filterExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,baseExpr,filterExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,baseExpr,filterExpr);
+ }
+
+ boolean exists = false;
+
+ @Override
+ public String getString() {
+ String value = baseExpr.getString();
+ exists = baseExpr.exists() && filterExpr.getBoolean() && filterExpr.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
\ No newline at end of file
+}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/IfFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/IfFunction.java
index ff28b90..a506e46 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/IfFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/IfFunction.java
@@ -172,722 +172,738 @@ public class IfFunction extends AbstractAnalyticsValueStream {
public ExpressionType getExpressionType() {
return funcType;
}
-}
-class ValueIfFunction extends AbstractAnalyticsValue {
- private final BooleanValue ifExpr;
- private final AnalyticsValue thenExpr;
- private final AnalyticsValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public ValueIfFunction(BooleanValue ifExpr, AnalyticsValue thenExpr, AnalyticsValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
-
- private boolean exists = false;
- @Override
- public Object getObject() {
- exists = false;
- Object value = null;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getObject();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getObject();
- exists = elseExpr.exists();
- }
+ static class ValueIfFunction extends AbstractAnalyticsValue {
+ private final BooleanValue ifExpr;
+ private final AnalyticsValue thenExpr;
+ private final AnalyticsValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public ValueIfFunction(BooleanValue ifExpr, AnalyticsValue thenExpr, AnalyticsValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanStreamIfFunction extends AbstractBooleanValueStream {
- private final BooleanValue ifExpr;
- private final BooleanValueStream thenExpr;
- private final BooleanValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
+ private boolean exists = false;
- public BooleanStreamIfFunction(BooleanValue ifExpr, BooleanValueStream thenExpr, BooleanValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
-
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamBooleans(cons);
- }
- else {
- elseExpr.streamBooleans(cons);
- }
+ @Override
+ public Object getObject() {
+ exists = false;
+ Object value = null;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getObject();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getObject();
+ exists = elseExpr.exists();
+ }
+ }
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ static class BooleanStreamIfFunction extends AbstractBooleanValueStream {
+ private final BooleanValue ifExpr;
+ private final BooleanValueStream thenExpr;
+ private final BooleanValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public BooleanStreamIfFunction(BooleanValue ifExpr, BooleanValueStream thenExpr, BooleanValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
+
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamBooleans(cons);
+ }
+ else {
+ elseExpr.streamBooleans(cons);
+ }
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class BooleanIfFunction extends AbstractBooleanValue {
- private final BooleanValue ifExpr;
- private final BooleanValue thenExpr;
- private final BooleanValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public BooleanIfFunction(BooleanValue ifExpr, BooleanValue thenExpr, BooleanValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class BooleanIfFunction extends AbstractBooleanValue {
+ private final BooleanValue ifExpr;
+ private final BooleanValue thenExpr;
+ private final BooleanValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public BooleanIfFunction(BooleanValue ifExpr, BooleanValue thenExpr, BooleanValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public boolean getBoolean() {
- exists = false;
- boolean value = false;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getBoolean();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getBoolean();
- exists = elseExpr.exists();
+ @Override
+ public boolean getBoolean() {
+ exists = false;
+ boolean value = false;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getBoolean();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getBoolean();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class IntStreamIfFunction extends AbstractIntValueStream {
- private final BooleanValue ifExpr;
- private final IntValueStream thenExpr;
- private final IntValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public IntStreamIfFunction(BooleanValue ifExpr, IntValueStream thenExpr, IntValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class IntStreamIfFunction extends AbstractIntValueStream {
+ private final BooleanValue ifExpr;
+ private final IntValueStream thenExpr;
+ private final IntValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public IntStreamIfFunction(BooleanValue ifExpr, IntValueStream thenExpr, IntValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- @Override
- public void streamInts(IntConsumer cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamInts(cons);
- }
- else {
- elseExpr.streamInts(cons);
+ @Override
+ public void streamInts(IntConsumer cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamInts(cons);
+ }
+ else {
+ elseExpr.streamInts(cons);
+ }
}
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class IntIfFunction extends AbstractIntValue {
- private final BooleanValue ifExpr;
- private final IntValue thenExpr;
- private final IntValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public IntIfFunction(BooleanValue ifExpr, IntValue thenExpr, IntValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class IntIfFunction extends AbstractIntValue {
+ private final BooleanValue ifExpr;
+ private final IntValue thenExpr;
+ private final IntValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public IntIfFunction(BooleanValue ifExpr, IntValue thenExpr, IntValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public int getInt() {
- exists = false;
- int value = 0;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getInt();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getInt();
- exists = elseExpr.exists();
+ @Override
+ public int getInt() {
+ exists = false;
+ int value = 0;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getInt();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getInt();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class LongStreamIfFunction extends AbstractLongValueStream {
- private final BooleanValue ifExpr;
- private final LongValueStream thenExpr;
- private final LongValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public LongStreamIfFunction(BooleanValue ifExpr, LongValueStream thenExpr, LongValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class LongStreamIfFunction extends AbstractLongValueStream {
+ private final BooleanValue ifExpr;
+ private final LongValueStream thenExpr;
+ private final LongValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public LongStreamIfFunction(BooleanValue ifExpr, LongValueStream thenExpr, LongValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamLongs(cons);
- }
- else {
- elseExpr.streamLongs(cons);
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamLongs(cons);
+ }
+ else {
+ elseExpr.streamLongs(cons);
+ }
}
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class LongIfFunction extends AbstractLongValue {
- private final BooleanValue ifExpr;
- private final LongValue thenExpr;
- private final LongValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public LongIfFunction(BooleanValue ifExpr, LongValue thenExpr, LongValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class LongIfFunction extends AbstractLongValue {
+ private final BooleanValue ifExpr;
+ private final LongValue thenExpr;
+ private final LongValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public LongIfFunction(BooleanValue ifExpr, LongValue thenExpr, LongValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public long getLong() {
- exists = false;
- long value = 0;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getLong();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getLong();
- exists = elseExpr.exists();
+ @Override
+ public long getLong() {
+ exists = false;
+ long value = 0;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getLong();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getLong();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class FloatStreamIfFunction extends AbstractFloatValueStream {
- private final BooleanValue ifExpr;
- private final FloatValueStream thenExpr;
- private final FloatValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public FloatStreamIfFunction(BooleanValue ifExpr, FloatValueStream thenExpr, FloatValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class FloatStreamIfFunction extends AbstractFloatValueStream {
+ private final BooleanValue ifExpr;
+ private final FloatValueStream thenExpr;
+ private final FloatValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public FloatStreamIfFunction(BooleanValue ifExpr, FloatValueStream thenExpr, FloatValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- @Override
- public void streamFloats(FloatConsumer cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamFloats(cons);
- }
- else {
- elseExpr.streamFloats(cons);
+ @Override
+ public void streamFloats(FloatConsumer cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamFloats(cons);
+ }
+ else {
+ elseExpr.streamFloats(cons);
+ }
}
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class FloatIfFunction extends AbstractFloatValue {
- private final BooleanValue ifExpr;
- private final FloatValue thenExpr;
- private final FloatValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public FloatIfFunction(BooleanValue ifExpr, FloatValue thenExpr, FloatValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class FloatIfFunction extends AbstractFloatValue {
+ private final BooleanValue ifExpr;
+ private final FloatValue thenExpr;
+ private final FloatValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public FloatIfFunction(BooleanValue ifExpr, FloatValue thenExpr, FloatValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public float getFloat() {
- exists = false;
- float value = 0;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getFloat();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getFloat();
- exists = elseExpr.exists();
+ @Override
+ public float getFloat() {
+ exists = false;
+ float value = 0;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getFloat();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getFloat();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class DoubleStreamIfFunction extends AbstractDoubleValueStream {
- private final BooleanValue ifExpr;
- private final DoubleValueStream thenExpr;
- private final DoubleValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DoubleStreamIfFunction(BooleanValue ifExpr, DoubleValueStream thenExpr, DoubleValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class DoubleStreamIfFunction extends AbstractDoubleValueStream {
+ private final BooleanValue ifExpr;
+ private final DoubleValueStream thenExpr;
+ private final DoubleValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DoubleStreamIfFunction(BooleanValue ifExpr, DoubleValueStream thenExpr, DoubleValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- @Override
- public void streamDoubles(DoubleConsumer cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamDoubles(cons);
- }
- else {
- elseExpr.streamDoubles(cons);
+ @Override
+ public void streamDoubles(DoubleConsumer cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamDoubles(cons);
+ }
+ else {
+ elseExpr.streamDoubles(cons);
+ }
}
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class DoubleIfFunction extends AbstractDoubleValue {
- private final BooleanValue ifExpr;
- private final DoubleValue thenExpr;
- private final DoubleValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DoubleIfFunction(BooleanValue ifExpr, DoubleValue thenExpr, DoubleValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class DoubleIfFunction extends AbstractDoubleValue {
+ private final BooleanValue ifExpr;
+ private final DoubleValue thenExpr;
+ private final DoubleValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DoubleIfFunction(BooleanValue ifExpr, DoubleValue thenExpr, DoubleValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public double getDouble() {
- exists = false;
- double value = 0;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getDouble();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getDouble();
- exists = elseExpr.exists();
+ @Override
+ public double getDouble() {
+ exists = false;
+ double value = 0;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getDouble();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getDouble();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class DateStreamIfFunction extends AbstractDateValueStream {
- private final BooleanValue ifExpr;
- private final DateValueStream thenExpr;
- private final DateValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DateStreamIfFunction(BooleanValue ifExpr, DateValueStream thenExpr, DateValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class DateStreamIfFunction extends AbstractDateValueStream {
+ private final BooleanValue ifExpr;
+ private final DateValueStream thenExpr;
+ private final DateValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateStreamIfFunction(BooleanValue ifExpr, DateValueStream thenExpr, DateValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamLongs(cons);
- }
- else {
- elseExpr.streamLongs(cons);
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamLongs(cons);
+ }
+ else {
+ elseExpr.streamLongs(cons);
+ }
}
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class DateIfFunction extends AbstractDateValue {
- private final BooleanValue ifExpr;
- private final DateValue thenExpr;
- private final DateValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DateIfFunction(BooleanValue ifExpr, DateValue thenExpr, DateValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class DateIfFunction extends AbstractDateValue {
+ private final BooleanValue ifExpr;
+ private final DateValue thenExpr;
+ private final DateValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateIfFunction(BooleanValue ifExpr, DateValue thenExpr, DateValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public long getLong() {
- exists = false;
- long value = 0;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getLong();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getLong();
- exists = elseExpr.exists();
+ @Override
+ public long getLong() {
+ exists = false;
+ long value = 0;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getLong();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getLong();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class StringStreamIfFunction extends AbstractStringValueStream {
- private final BooleanValue ifExpr;
- private final StringValueStream thenExpr;
- private final StringValueStream elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public StringStreamIfFunction(BooleanValue ifExpr, StringValueStream thenExpr, StringValueStream elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class StringStreamIfFunction extends AbstractStringValueStream {
+ private final BooleanValue ifExpr;
+ private final StringValueStream thenExpr;
+ private final StringValueStream elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamStrings(Consumer<String> cons) {
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- thenExpr.streamStrings(cons);
- }
- else {
- elseExpr.streamStrings(cons);
+ public StringStreamIfFunction(BooleanValue ifExpr, StringValueStream thenExpr, StringValueStream elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
+
+ @Override
+ public void streamStrings(Consumer<String> cons) {
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ thenExpr.streamStrings(cons);
+ }
+ else {
+ elseExpr.streamStrings(cons);
+ }
}
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class StringIfFunction extends AbstractStringValue {
- private final BooleanValue ifExpr;
- private final StringValue thenExpr;
- private final StringValue elseExpr;
- public static final String name = IfFunction.name;
- private final String exprStr;
- private final ExpressionType funcType;
- public StringIfFunction(BooleanValue ifExpr, StringValue thenExpr, StringValue elseExpr) throws SolrException {
- this.ifExpr = ifExpr;
- this.thenExpr = thenExpr;
- this.elseExpr = elseExpr;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
- }
+ static class StringIfFunction extends AbstractStringValue {
+ private final BooleanValue ifExpr;
+ private final StringValue thenExpr;
+ private final StringValue elseExpr;
+ public static final String name = IfFunction.name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- private boolean exists = false;
+ public StringIfFunction(BooleanValue ifExpr, StringValue thenExpr, StringValue elseExpr) throws SolrException {
+ this.ifExpr = ifExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,ifExpr,thenExpr,elseExpr);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,ifExpr,thenExpr,elseExpr);
+ }
- @Override
- public String getString() {
- exists = false;
- String value = null;
- boolean ifValue = ifExpr.getBoolean();
- if (ifExpr.exists()) {
- if (ifValue) {
- value = thenExpr.getString();
- exists = thenExpr.exists();
- }
- else {
- value = elseExpr.getString();
- exists = elseExpr.exists();
+ private boolean exists = false;
+
+ @Override
+ public String getString() {
+ exists = false;
+ String value = null;
+ boolean ifValue = ifExpr.getBoolean();
+ if (ifExpr.exists()) {
+ if (ifValue) {
+ value = thenExpr.getString();
+ exists = thenExpr.exists();
+ }
+ else {
+ value = elseExpr.getString();
+ exists = elseExpr.exists();
+ }
}
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
\ No newline at end of file
+}
+
diff --git a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/LambdaFunction.java b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/LambdaFunction.java
index fcaf332..ff72bec 100644
--- a/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/LambdaFunction.java
+++ b/solr/contrib/analytics/src/java/org/apache/solr/analytics/function/mapping/LambdaFunction.java
@@ -21,18 +21,6 @@ import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.function.LongConsumer;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.BoolInBoolOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.DoubleInDoubleOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.FloatInFloatOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.IntInIntOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.LongInLongOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.StringInStringOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.TwoBoolInBoolOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.TwoDoubleInDoubleOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.TwoFloatInFloatOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.TwoIntInIntOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.TwoLongInLongOutLambda;
-import org.apache.solr.analytics.function.mapping.LambdaFunction.TwoStringInStringOutLambda;
import org.apache.solr.analytics.util.function.BooleanConsumer;
import org.apache.solr.analytics.util.function.FloatConsumer;
import org.apache.solr.analytics.value.AnalyticsValueStream;
@@ -958,2263 +946,2313 @@ public class LambdaFunction {
public static interface TwoDoubleInStringOutLambda { String apply(double a, double b); }
@FunctionalInterface
public static interface TwoStringInStringOutLambda { String apply(String a, String b); }
-}
-class BooleanValueInBooleanValueOutFunction extends AbstractBooleanValue {
- private final BooleanValue param;
- private final BoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public BooleanValueInBooleanValueOutFunction(String name, BoolInBoolOutLambda lambda, BooleanValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ static class BooleanValueInBooleanValueOutFunction extends AbstractBooleanValue {
+ private final BooleanValue param;
+ private final BoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public BooleanValueInBooleanValueOutFunction(String name, BoolInBoolOutLambda lambda, BooleanValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- private boolean exists = false;
+ private boolean exists = false;
- @Override
- public boolean getBoolean() {
- boolean value = lambda.apply(param.getBoolean());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ @Override
+ public boolean getBoolean() {
+ boolean value = lambda.apply(param.getBoolean());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class BooleanStreamInBooleanStreamOutFunction extends AbstractBooleanValueStream {
- private final BooleanValueStream param;
- private final BoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public BooleanStreamInBooleanStreamOutFunction(String name, BoolInBoolOutLambda lambda, BooleanValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ static class BooleanStreamInBooleanStreamOutFunction extends AbstractBooleanValueStream {
+ private final BooleanValueStream param;
+ private final BoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- param.streamBooleans(value -> cons.accept(lambda.apply(value)));
- }
+ public BooleanStreamInBooleanStreamOutFunction(String name, BoolInBoolOutLambda lambda, BooleanValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanStreamInBooleanValueOutFunction extends AbstractBooleanValue implements BooleanConsumer {
- private final BooleanValueStream param;
- private final TwoBoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public BooleanStreamInBooleanValueOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private boolean value;
-
- @Override
- public boolean getBoolean() {
- exists = false;
- param.streamBooleans(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(boolean paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ param.streamBooleans(value -> cons.accept(lambda.apply(value)));
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class TwoBooleanValueInBooleanValueOutFunction extends AbstractBooleanValue {
- private final BooleanValue param1;
- private final BooleanValue param2;
- private final TwoBoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public TwoBooleanValueInBooleanValueOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue param1, BooleanValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class BooleanStreamInBooleanValueOutFunction extends AbstractBooleanValue implements BooleanConsumer {
+ private final BooleanValueStream param;
+ private final TwoBoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- private boolean exists = false;
+ public BooleanStreamInBooleanValueOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public boolean getBoolean() {
- boolean value = lambda.apply(param1.getBoolean(), param2.getBoolean());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ private boolean exists = false;
+ private boolean value;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanValueBooleanStreamInBooleanStreamOutFunction extends AbstractBooleanValueStream {
- private final BooleanValue param1;
- private final BooleanValueStream param2;
- private final TwoBoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ @Override
+ public boolean getBoolean() {
+ exists = false;
+ param.streamBooleans(this);
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+ public void accept(boolean paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
+ }
+ }
- public BooleanValueBooleanStreamInBooleanStreamOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue param1, BooleanValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- boolean value1 = param1.getBoolean();
- if (param1.exists()) {
- param2.streamBooleans(value2 -> cons.accept(lambda.apply(value1,value2)));
+ static class TwoBooleanValueInBooleanValueOutFunction extends AbstractBooleanValue {
+ private final BooleanValue param1;
+ private final BooleanValue param2;
+ private final TwoBoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoBooleanValueInBooleanValueOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue param1, BooleanValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class BooleanStreamBooleanValueInBooleanStreamOutFunction extends AbstractBooleanValueStream {
- private final BooleanValueStream param1;
- private final BooleanValue param2;
- private final TwoBoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ private boolean exists = false;
- public BooleanStreamBooleanValueInBooleanStreamOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValueStream param1, BooleanValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ @Override
+ public boolean getBoolean() {
+ boolean value = lambda.apply(param1.getBoolean(), param2.getBoolean());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public void streamBooleans(BooleanConsumer cons) {
- boolean value2 = param2.getBoolean();
- if (param2.exists()) {
- param1.streamBooleans(value1 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-abstract class MultiBooleanValueInBooleanValueOutFunction extends AbstractBooleanValue {
- protected final BooleanValue[] params;
- protected final TwoBoolInBoolOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class BooleanValueBooleanStreamInBooleanStreamOutFunction extends AbstractBooleanValueStream {
+ private final BooleanValue param1;
+ private final BooleanValueStream param2;
+ private final TwoBoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public BooleanValueBooleanStreamInBooleanStreamOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue param1, BooleanValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- public MultiBooleanValueInBooleanValueOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
- }
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ boolean value1 = param1.getBoolean();
+ if (param1.exists()) {
+ param2.streamBooleans(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- protected boolean exists = false;
- protected boolean temp;
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class MultiBooleanValueInBooleanValueOutRequireAllFunction extends MultiBooleanValueInBooleanValueOutFunction {
+ static class BooleanStreamBooleanValueInBooleanStreamOutFunction extends AbstractBooleanValueStream {
+ private final BooleanValueStream param1;
+ private final BooleanValue param2;
+ private final TwoBoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public BooleanStreamBooleanValueInBooleanStreamOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValueStream param1, BooleanValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- public MultiBooleanValueInBooleanValueOutRequireAllFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue[] params) {
- super(name, lambda, params);
- }
+ @Override
+ public void streamBooleans(BooleanConsumer cons) {
+ boolean value2 = param2.getBoolean();
+ if (param2.exists()) {
+ param1.streamBooleans(value1 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- @Override
- public boolean getBoolean() {
- boolean value = params[0].getBoolean();
- exists = params[0].exists();
- for (int i = 1; i < params.length && exists; ++i) {
- value = lambda.apply(value, params[i].getBoolean());
- exists = params[i].exists();
+ @Override
+ public String getName() {
+ return name;
}
- return value;
- }
-}
-class MultiBooleanValueInBooleanValueOutRequireOneFunction extends MultiBooleanValueInBooleanValueOutFunction {
-
- public MultiBooleanValueInBooleanValueOutRequireOneFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue[] params) {
- super(name, lambda, params);
- }
-
- @Override
- public boolean getBoolean() {
- int i = -1;
- boolean value = false;
- exists = false;
- while (++i < params.length) {
- value = params[i].getBoolean();
- exists = params[i].exists();
- if (exists) {
- break;
- }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
}
- while (++i < params.length) {
- temp = params[i].getBoolean();
- if (params[i].exists()) {
- value = lambda.apply(value, temp);
- }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
- }
-}
-class IntValueInIntValueOutFunction extends AbstractIntValue {
- private final IntValue param;
- private final IntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public IntValueInIntValueOutFunction(String name, IntInIntOutLambda lambda, IntValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
}
- private boolean exists = false;
+ abstract static class MultiBooleanValueInBooleanValueOutFunction extends AbstractBooleanValue {
+ protected final BooleanValue[] params;
+ protected final TwoBoolInBoolOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public int getInt() {
- int value = lambda.apply(param.getInt());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public MultiBooleanValueInBooleanValueOutFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntStreamInIntStreamOutFunction extends AbstractIntValueStream {
- private final IntValueStream param;
- private final IntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ protected boolean exists = false;
+ protected boolean temp;
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- public IntStreamInIntStreamOutFunction(String name, IntInIntOutLambda lambda, IntValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamInts(IntConsumer cons) {
- param.streamInts(value -> cons.accept(lambda.apply(value)));
- }
+ static class MultiBooleanValueInBooleanValueOutRequireAllFunction extends MultiBooleanValueInBooleanValueOutFunction {
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntStreamInIntValueOutFunction extends AbstractIntValue implements IntConsumer {
- private final IntValueStream param;
- private final TwoIntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public IntStreamInIntValueOutFunction(String name, TwoIntInIntOutLambda lambda, IntValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private int value;
-
- @Override
- public int getInt() {
- exists = false;
- param.streamInts(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(int paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ public MultiBooleanValueInBooleanValueOutRequireAllFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue[] params) {
+ super(name, lambda, params);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public boolean getBoolean() {
+ boolean value = params[0].getBoolean();
+ exists = params[0].exists();
+ for (int i = 1; i < params.length && exists; ++i) {
+ value = lambda.apply(value, params[i].getBoolean());
+ exists = params[i].exists();
+ }
+ return value;
+ }
}
-}
-class TwoIntValueInIntValueOutFunction extends AbstractIntValue {
- private final IntValue param1;
- private final IntValue param2;
- private final TwoIntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public TwoIntValueInIntValueOutFunction(String name, TwoIntInIntOutLambda lambda, IntValue param1, IntValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class MultiBooleanValueInBooleanValueOutRequireOneFunction extends MultiBooleanValueInBooleanValueOutFunction {
- private boolean exists = false;
+ public MultiBooleanValueInBooleanValueOutRequireOneFunction(String name, TwoBoolInBoolOutLambda lambda, BooleanValue[] params) {
+ super(name, lambda, params);
+ }
- @Override
- public int getInt() {
- int value = lambda.apply(param1.getInt(), param2.getInt());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public boolean getBoolean() {
+ int i = -1;
+ boolean value = false;
+ exists = false;
+ while (++i < params.length) {
+ value = params[i].getBoolean();
+ exists = params[i].exists();
+ if (exists) {
+ break;
+ }
+ }
+ while (++i < params.length) {
+ temp = params[i].getBoolean();
+ if (params[i].exists()) {
+ value = lambda.apply(value, temp);
+ }
+ }
+ return value;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class IntValueIntStreamInIntStreamOutFunction extends AbstractIntValueStream {
- private final IntValue param1;
- private final IntValueStream param2;
- private final TwoIntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class IntValueInIntValueOutFunction extends AbstractIntValue {
+ private final IntValue param;
+ private final IntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- public IntValueIntStreamInIntStreamOutFunction(String name, TwoIntInIntOutLambda lambda, IntValue param1, IntValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ public IntValueInIntValueOutFunction(String name, IntInIntOutLambda lambda, IntValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ private boolean exists = false;
- @Override
- public void streamInts(IntConsumer cons) {
- int value1 = param1.getInt();
- if (param1.exists()) {
- param2.streamInts(value2 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public int getInt() {
+ int value = lambda.apply(param.getInt());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class IntStreamIntValueInIntStreamOutFunction extends AbstractIntValueStream {
- private final IntValueStream param1;
- private final IntValue param2;
- private final TwoIntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public IntStreamIntValueInIntStreamOutFunction(String name, TwoIntInIntOutLambda lambda, IntValueStream param1, IntValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class IntStreamInIntStreamOutFunction extends AbstractIntValueStream {
+ private final IntValueStream param;
+ private final IntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamInts(IntConsumer cons) {
- int value2 = param2.getInt();
- if (param2.exists()) {
- param1.streamInts(value1 -> cons.accept(lambda.apply(value1,value2)));
+ public IntStreamInIntStreamOutFunction(String name, IntInIntOutLambda lambda, IntValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-abstract class MultiIntValueInIntValueOutFunction extends AbstractIntValue {
- protected final IntValue[] params;
- protected final TwoIntInIntOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ @Override
+ public void streamInts(IntConsumer cons) {
+ param.streamInts(value -> cons.accept(lambda.apply(value)));
+ }
- public MultiIntValueInIntValueOutFunction(String name, TwoIntInIntOutLambda lambda, IntValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- protected boolean exists = false;
- protected int temp;
- @Override
- public boolean exists() {
- return exists;
- }
+ static class IntStreamInIntValueOutFunction extends AbstractIntValue implements IntConsumer {
+ private final IntValueStream param;
+ private final TwoIntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class MultiIntValueInIntValueOutRequireAllFunction extends MultiIntValueInIntValueOutFunction {
+ public IntStreamInIntValueOutFunction(String name, TwoIntInIntOutLambda lambda, IntValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- public MultiIntValueInIntValueOutRequireAllFunction(String name, TwoIntInIntOutLambda lambda, IntValue[] params) {
- super(name, lambda, params);
- }
+ private boolean exists = false;
+ private int value;
- @Override
- public int getInt() {
- int value = params[0].getInt();
- exists = params[0].exists();
- for (int i = 1; i < params.length && exists; ++i) {
- value = lambda.apply(value, params[i].getInt());
- exists = params[i].exists();
+ @Override
+ public int getInt() {
+ exists = false;
+ param.streamInts(this);
+ return value;
}
- return value;
- }
-}
-class MultiIntValueInIntValueOutRequireOneFunction extends MultiIntValueInIntValueOutFunction {
-
- public MultiIntValueInIntValueOutRequireOneFunction(String name, TwoIntInIntOutLambda lambda, IntValue[] params) {
- super(name, lambda, params);
- }
-
- @Override
- public int getInt() {
- int i = -1;
- int value = 0;
- exists = false;
- while (++i < params.length) {
- value = params[i].getInt();
- exists = params[i].exists();
- if (exists) {
- break;
- }
+ @Override
+ public boolean exists() {
+ return exists;
}
- while (++i < params.length) {
- temp = params[i].getInt();
- if (params[i].exists()) {
- value = lambda.apply(value, temp);
+ public void accept(int paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
}
}
- return value;
- }
-}
-class LongValueInLongValueOutFunction extends AbstractLongValue {
- private final LongValue param;
- private final LongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongValueInLongValueOutFunction(String name, LongInLongOutLambda lambda, LongValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
-
- @Override
- public long getLong() {
- long value = lambda.apply(param.getLong());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class LongStreamInLongStreamOutFunction extends AbstractLongValueStream {
- private final LongValueStream param;
- private final LongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public LongStreamInLongStreamOutFunction(String name, LongInLongOutLambda lambda, LongValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ static class TwoIntValueInIntValueOutFunction extends AbstractIntValue {
+ private final IntValue param1;
+ private final IntValue param2;
+ private final TwoIntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoIntValueInIntValueOutFunction(String name, TwoIntInIntOutLambda lambda, IntValue param1, IntValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- param.streamLongs(value -> cons.accept(lambda.apply(value)));
- }
+ private boolean exists = false;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongStreamInLongValueOutFunction extends AbstractLongValue implements LongConsumer {
- private final LongValueStream param;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public LongStreamInLongValueOutFunction(String name, TwoLongInLongOutLambda lambda, LongValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private long value;
-
- @Override
- public long getLong() {
- exists = false;
- param.streamLongs(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(long paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ @Override
+ public int getInt() {
+ int value = lambda.apply(param1.getInt(), param2.getInt());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class TwoLongValueInLongValueOutFunction extends AbstractLongValue {
- private final LongValue param1;
- private final LongValue param2;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public TwoLongValueInLongValueOutFunction(String name, TwoLongInLongOutLambda lambda, LongValue param1, LongValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class IntValueIntStreamInIntStreamOutFunction extends AbstractIntValueStream {
+ private final IntValue param1;
+ private final IntValueStream param2;
+ private final TwoIntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public IntValueIntStreamInIntStreamOutFunction(String name, TwoIntInIntOutLambda lambda, IntValue param1, IntValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- private boolean exists = false;
+ @Override
+ public void streamInts(IntConsumer cons) {
+ int value1 = param1.getInt();
+ if (param1.exists()) {
+ param2.streamInts(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- @Override
- public long getLong() {
- long value = lambda.apply(param1.getLong(), param2.getLong());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongValueLongStreamInLongStreamOutFunction extends AbstractLongValueStream {
- private final LongValue param1;
- private final LongValueStream param2;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class IntStreamIntValueInIntStreamOutFunction extends AbstractIntValueStream {
+ private final IntValueStream param1;
+ private final IntValue param2;
+ private final TwoIntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public IntStreamIntValueInIntStreamOutFunction(String name, TwoIntInIntOutLambda lambda, IntValueStream param1, IntValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- public LongValueLongStreamInLongStreamOutFunction(String name, TwoLongInLongOutLambda lambda, LongValue param1, LongValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ @Override
+ public void streamInts(IntConsumer cons) {
+ int value2 = param2.getInt();
+ if (param2.exists()) {
+ param1.streamInts(value1 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- long value1 = param1.getLong();
- if (param1.exists()) {
- param2.streamLongs(value2 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class LongStreamLongValueInLongStreamOutFunction extends AbstractLongValueStream {
- private final LongValueStream param1;
- private final LongValue param2;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ abstract static class MultiIntValueInIntValueOutFunction extends AbstractIntValue {
+ protected final IntValue[] params;
+ protected final TwoIntInIntOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- public LongStreamLongValueInLongStreamOutFunction(String name, TwoLongInLongOutLambda lambda, LongValueStream param1, LongValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ public MultiIntValueInIntValueOutFunction(String name, TwoIntInIntOutLambda lambda, IntValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
- @Override
- public void streamLongs(LongConsumer cons) {
- long value2 = param2.getLong();
- if (param2.exists()) {
- param1.streamLongs(value1 -> cons.accept(lambda.apply(value1,value2)));
+ protected boolean exists = false;
+ protected int temp;
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-abstract class MultiLongValueInLongValueOutFunction extends AbstractLongValue {
- protected final LongValue[] params;
- protected final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public MultiLongValueInLongValueOutFunction(String name, TwoLongInLongOutLambda lambda, LongValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
- }
+ static class MultiIntValueInIntValueOutRequireAllFunction extends MultiIntValueInIntValueOutFunction {
- protected boolean exists = false;
- protected long temp;
- @Override
- public boolean exists() {
- return exists;
- }
+ public MultiIntValueInIntValueOutRequireAllFunction(String name, TwoIntInIntOutLambda lambda, IntValue[] params) {
+ super(name, lambda, params);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public int getInt() {
+ int value = params[0].getInt();
+ exists = params[0].exists();
+ for (int i = 1; i < params.length && exists; ++i) {
+ value = lambda.apply(value, params[i].getInt());
+ exists = params[i].exists();
+ }
+ return value;
+ }
}
-}
-class MultiLongValueInLongValueOutRequireAllFunction extends MultiLongValueInLongValueOutFunction {
- public MultiLongValueInLongValueOutRequireAllFunction(String name, TwoLongInLongOutLambda lambda, LongValue[] params) {
- super(name, lambda, params);
- }
+ static class MultiIntValueInIntValueOutRequireOneFunction extends MultiIntValueInIntValueOutFunction {
- @Override
- public long getLong() {
- long value = params[0].getLong();
- exists = params[0].exists();
- for (int i = 1; i < params.length && exists; ++i) {
- value = lambda.apply(value, params[i].getLong());
- exists = params[i].exists();
+ public MultiIntValueInIntValueOutRequireOneFunction(String name, TwoIntInIntOutLambda lambda, IntValue[] params) {
+ super(name, lambda, params);
}
- return value;
- }
-}
-class MultiLongValueInLongValueOutRequireOneFunction extends MultiLongValueInLongValueOutFunction {
-
- public MultiLongValueInLongValueOutRequireOneFunction(String name, TwoLongInLongOutLambda lambda, LongValue[] params) {
- super(name, lambda, params);
- }
-
- @Override
- public long getLong() {
- int i = -1;
- long value = 0;
- exists = false;
- while (++i < params.length) {
- value = params[i].getLong();
- exists = params[i].exists();
- if (exists) {
- break;
+
+ @Override
+ public int getInt() {
+ int i = -1;
+ int value = 0;
+ exists = false;
+ while (++i < params.length) {
+ value = params[i].getInt();
+ exists = params[i].exists();
+ if (exists) {
+ break;
+ }
}
- }
- while (++i < params.length) {
- temp = params[i].getLong();
- if (params[i].exists()) {
- value = lambda.apply(value, temp);
+ while (++i < params.length) {
+ temp = params[i].getInt();
+ if (params[i].exists()) {
+ value = lambda.apply(value, temp);
+ }
}
+ return value;
}
- return value;
}
-}
-class FloatValueInFloatValueOutFunction extends AbstractFloatValue {
- private final FloatValue param;
- private final FloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public FloatValueInFloatValueOutFunction(String name, FloatInFloatOutLambda lambda, FloatValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ static class LongValueInLongValueOutFunction extends AbstractLongValue {
+ private final LongValue param;
+ private final LongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- private boolean exists = false;
+ public LongValueInLongValueOutFunction(String name, LongInLongOutLambda lambda, LongValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public float getFloat() {
- float value = lambda.apply(param.getFloat());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ private boolean exists = false;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatStreamInFloatStreamOutFunction extends AbstractFloatValueStream {
- private final FloatValueStream param;
- private final FloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ @Override
+ public long getLong() {
+ long value = lambda.apply(param.getLong());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- public FloatStreamInFloatStreamOutFunction(String name, FloatInFloatOutLambda lambda, FloatValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamFloats(FloatConsumer cons) {
- param.streamFloats(value -> cons.accept(lambda.apply(value)));
- }
+ static class LongStreamInLongStreamOutFunction extends AbstractLongValueStream {
+ private final LongValueStream param;
+ private final LongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatStreamInFloatValueOutFunction extends AbstractFloatValue implements FloatConsumer {
- private final FloatValueStream param;
- private final TwoFloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public FloatStreamInFloatValueOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private float value;
-
- @Override
- public float getFloat() {
- exists = false;
- param.streamFloats(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(float paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ public LongStreamInLongStreamOutFunction(String name, LongInLongOutLambda lambda, LongValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class TwoFloatValueInFloatValueOutFunction extends AbstractFloatValue {
- private final FloatValue param1;
- private final FloatValue param2;
- private final TwoFloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ param.streamLongs(value -> cons.accept(lambda.apply(value)));
+ }
- public TwoFloatValueInFloatValueOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue param1, FloatValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- private boolean exists = false;
+ static class LongStreamInLongValueOutFunction extends AbstractLongValue implements LongConsumer {
+ private final LongValueStream param;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public float getFloat() {
- float value = lambda.apply(param1.getFloat(), param2.getFloat());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public LongStreamInLongValueOutFunction(String name, TwoLongInLongOutLambda lambda, LongValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatValueFloatStreamInFloatStreamOutFunction extends AbstractFloatValueStream {
- private final FloatValue param1;
- private final FloatValueStream param2;
- private final TwoFloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ private boolean exists = false;
+ private long value;
- public FloatValueFloatStreamInFloatStreamOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue param1, FloatValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ @Override
+ public long getLong() {
+ exists = false;
+ param.streamLongs(this);
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+ public void accept(long paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
+ }
+ }
- @Override
- public void streamFloats(FloatConsumer cons) {
- float value1 = param1.getFloat();
- if (param1.exists()) {
- param2.streamFloats(value2 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class FloatStreamFloatValueInFloatStreamOutFunction extends AbstractFloatValueStream {
- private final FloatValueStream param1;
- private final FloatValue param2;
- private final TwoFloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class TwoLongValueInLongValueOutFunction extends AbstractLongValue {
+ private final LongValue param1;
+ private final LongValue param2;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoLongValueInLongValueOutFunction(String name, TwoLongInLongOutLambda lambda, LongValue param1, LongValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- public FloatStreamFloatValueInFloatStreamOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValueStream param1, FloatValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ private boolean exists = false;
- @Override
- public void streamFloats(FloatConsumer cons) {
- float value2 = param2.getFloat();
- if (param2.exists()) {
- param1.streamFloats(value1 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public long getLong() {
+ long value = lambda.apply(param1.getLong(), param2.getLong());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-abstract class MultiFloatValueInFloatValueOutFunction extends AbstractFloatValue {
- protected final FloatValue[] params;
- protected final TwoFloatInFloatOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public MultiFloatValueInFloatValueOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
- }
+ static class LongValueLongStreamInLongStreamOutFunction extends AbstractLongValueStream {
+ private final LongValue param1;
+ private final LongValueStream param2;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public LongValueLongStreamInLongStreamOutFunction(String name, TwoLongInLongOutLambda lambda, LongValue param1, LongValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- protected boolean exists = false;
- protected float temp;
- @Override
- public boolean exists() {
- return exists;
- }
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ long value1 = param1.getLong();
+ if (param1.exists()) {
+ param2.streamLongs(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class MultiFloatValueInFloatValueOutRequireAllFunction extends MultiFloatValueInFloatValueOutFunction {
- public MultiFloatValueInFloatValueOutRequireAllFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue[] params) {
- super(name, lambda, params);
+ static class LongStreamLongValueInLongStreamOutFunction extends AbstractLongValueStream {
+ private final LongValueStream param1;
+ private final LongValue param2;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public LongStreamLongValueInLongStreamOutFunction(String name, TwoLongInLongOutLambda lambda, LongValueStream param1, LongValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ long value2 = param2.getLong();
+ if (param2.exists()) {
+ param1.streamLongs(value1 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public float getFloat() {
- float value = params[0].getFloat();
- exists = params[0].exists();
- for (int i = 1; i < params.length && exists; ++i) {
- value = lambda.apply(value, params[i].getFloat());
- exists = params[i].exists();
+ abstract static class MultiLongValueInLongValueOutFunction extends AbstractLongValue {
+ protected final LongValue[] params;
+ protected final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public MultiLongValueInLongValueOutFunction(String name, TwoLongInLongOutLambda lambda, LongValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
+
+ protected boolean exists = false;
+ protected long temp;
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
}
-}
-class MultiFloatValueInFloatValueOutRequireOneFunction extends MultiFloatValueInFloatValueOutFunction {
-
- public MultiFloatValueInFloatValueOutRequireOneFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue[] params) {
- super(name, lambda, params);
- }
-
- @Override
- public float getFloat() {
- int i = -1;
- float value = 0;
- exists = false;
- while (++i < params.length) {
- value = params[i].getFloat();
- exists = params[i].exists();
- if (exists) {
- break;
- }
+
+ static class MultiLongValueInLongValueOutRequireAllFunction extends MultiLongValueInLongValueOutFunction {
+
+ public MultiLongValueInLongValueOutRequireAllFunction(String name, TwoLongInLongOutLambda lambda, LongValue[] params) {
+ super(name, lambda, params);
}
- while (++i < params.length) {
- temp = params[i].getFloat();
- if (params[i].exists()) {
- value = lambda.apply(value, temp);
+
+ @Override
+ public long getLong() {
+ long value = params[0].getLong();
+ exists = params[0].exists();
+ for (int i = 1; i < params.length && exists; ++i) {
+ value = lambda.apply(value, params[i].getLong());
+ exists = params[i].exists();
}
+ return value;
}
- return value;
}
-}
-class DoubleValueInDoubleValueOutFunction extends AbstractDoubleValue {
- private final DoubleValue param;
- private final DoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DoubleValueInDoubleValueOutFunction(String name, DoubleInDoubleOutLambda lambda, DoubleValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ static class MultiLongValueInLongValueOutRequireOneFunction extends MultiLongValueInLongValueOutFunction {
- private boolean exists = false;
+ public MultiLongValueInLongValueOutRequireOneFunction(String name, TwoLongInLongOutLambda lambda, LongValue[] params) {
+ super(name, lambda, params);
+ }
- @Override
- public double getDouble() {
- double value = lambda.apply(param.getDouble());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public long getLong() {
+ int i = -1;
+ long value = 0;
+ exists = false;
+ while (++i < params.length) {
+ value = params[i].getLong();
+ exists = params[i].exists();
+ if (exists) {
+ break;
+ }
+ }
+ while (++i < params.length) {
+ temp = params[i].getLong();
+ if (params[i].exists()) {
+ value = lambda.apply(value, temp);
+ }
+ }
+ return value;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleStreamInDoubleStreamOutFunction extends AbstractDoubleValueStream {
- private final DoubleValueStream param;
- private final DoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class FloatValueInFloatValueOutFunction extends AbstractFloatValue {
+ private final FloatValue param;
+ private final FloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- public DoubleStreamInDoubleStreamOutFunction(String name, DoubleInDoubleOutLambda lambda, DoubleValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
+ public FloatValueInFloatValueOutFunction(String name, FloatInFloatOutLambda lambda, FloatValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public void streamDoubles(DoubleConsumer cons) {
- param.streamDoubles(value -> cons.accept(lambda.apply(value)));
- }
+ private boolean exists = false;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleStreamInDoubleValueOutFunction extends AbstractDoubleValue implements DoubleConsumer {
- private final DoubleValueStream param;
- private final TwoDoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DoubleStreamInDoubleValueOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private double value;
-
- @Override
- public double getDouble() {
- exists = false;
- param.streamDoubles(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(double paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ @Override
+ public float getFloat() {
+ float value = lambda.apply(param.getFloat());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class TwoDoubleValueInDoubleValueOutFunction extends AbstractDoubleValue {
- private final DoubleValue param1;
- private final DoubleValue param2;
- private final TwoDoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public TwoDoubleValueInDoubleValueOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue param1, DoubleValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class FloatStreamInFloatStreamOutFunction extends AbstractFloatValueStream {
+ private final FloatValueStream param;
+ private final FloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- private boolean exists = false;
+ public FloatStreamInFloatStreamOutFunction(String name, FloatInFloatOutLambda lambda, FloatValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- @Override
- public double getDouble() {
- double value = lambda.apply(param1.getDouble(), param2.getDouble());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ @Override
+ public void streamFloats(FloatConsumer cons) {
+ param.streamFloats(value -> cons.accept(lambda.apply(value)));
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class DoubleValueDoubleStreamInDoubleStreamOutFunction extends AbstractDoubleValueStream {
- private final DoubleValue param1;
- private final DoubleValueStream param2;
- private final TwoDoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DoubleValueDoubleStreamInDoubleStreamOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue param1, DoubleValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class FloatStreamInFloatValueOutFunction extends AbstractFloatValue implements FloatConsumer {
+ private final FloatValueStream param;
+ private final TwoFloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamDoubles(DoubleConsumer cons) {
- double value1 = param1.getDouble();
- if (param1.exists()) {
- param2.streamDoubles(value2 -> cons.accept(lambda.apply(value1,value2)));
+ public FloatStreamInFloatValueOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DoubleStreamDoubleValueInDoubleStreamOutFunction extends AbstractDoubleValueStream {
- private final DoubleValueStream param1;
- private final DoubleValue param2;
- private final TwoDoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ private boolean exists = false;
+ private float value;
- public DoubleStreamDoubleValueInDoubleStreamOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValueStream param1, DoubleValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ @Override
+ public float getFloat() {
+ exists = false;
+ param.streamFloats(this);
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+ public void accept(float paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
+ }
+ }
- @Override
- public void streamDoubles(DoubleConsumer cons) {
- double value2 = param2.getDouble();
- if (param2.exists()) {
- param1.streamDoubles(value1 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-abstract class MultiDoubleValueInDoubleValueOutFunction extends AbstractDoubleValue {
- protected final DoubleValue[] params;
- protected final TwoDoubleInDoubleOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class TwoFloatValueInFloatValueOutFunction extends AbstractFloatValue {
+ private final FloatValue param1;
+ private final FloatValue param2;
+ private final TwoFloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoFloatValueInFloatValueOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue param1, FloatValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- public MultiDoubleValueInDoubleValueOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
- }
+ private boolean exists = false;
- protected boolean exists = false;
- protected double temp;
- @Override
- public boolean exists() {
- return exists;
- }
+ @Override
+ public float getFloat() {
+ float value = lambda.apply(param1.getFloat(), param2.getFloat());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class MultiDoubleValueInDoubleValueOutRequireAllFunction extends MultiDoubleValueInDoubleValueOutFunction {
- public MultiDoubleValueInDoubleValueOutRequireAllFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue[] params) {
- super(name, lambda, params);
- }
+ static class FloatValueFloatStreamInFloatStreamOutFunction extends AbstractFloatValueStream {
+ private final FloatValue param1;
+ private final FloatValueStream param2;
+ private final TwoFloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public FloatValueFloatStreamInFloatStreamOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue param1, FloatValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ @Override
+ public void streamFloats(FloatConsumer cons) {
+ float value1 = param1.getFloat();
+ if (param1.exists()) {
+ param2.streamFloats(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- @Override
- public double getDouble() {
- double value = params[0].getDouble();
- exists = params[0].exists();
- for (int i = 1; i < params.length && exists; ++i) {
- value = lambda.apply(value, params[i].getDouble());
- exists = params[i].exists();
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
- return value;
}
-}
-class MultiDoubleValueInDoubleValueOutRequireOneFunction extends MultiDoubleValueInDoubleValueOutFunction {
-
- public MultiDoubleValueInDoubleValueOutRequireOneFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue[] params) {
- super(name, lambda, params);
- }
-
- @Override
- public double getDouble() {
- int i = -1;
- double value = 0;
- exists = false;
- while (++i < params.length) {
- value = params[i].getDouble();
- exists = params[i].exists();
- if (exists) {
- break;
- }
+
+ static class FloatStreamFloatValueInFloatStreamOutFunction extends AbstractFloatValueStream {
+ private final FloatValueStream param1;
+ private final FloatValue param2;
+ private final TwoFloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public FloatStreamFloatValueInFloatStreamOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValueStream param1, FloatValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
}
- while (++i < params.length) {
- temp = params[i].getDouble();
- if (params[i].exists()) {
- value = lambda.apply(value, temp);
+
+ @Override
+ public void streamFloats(FloatConsumer cons) {
+ float value2 = param2.getFloat();
+ if (param2.exists()) {
+ param1.streamFloats(value1 -> cons.accept(lambda.apply(value1,value2)));
}
}
- return value;
- }
-}
-class DateValueInDateValueOutFunction extends AbstractDateValue {
- private final DateValue param;
- private final LongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DateValueInDateValueOutFunction(String name, LongInLongOutLambda lambda, DateValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- private boolean exists = false;
+ abstract static class MultiFloatValueInFloatValueOutFunction extends AbstractFloatValue {
+ protected final FloatValue[] params;
+ protected final TwoFloatInFloatOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public long getLong() {
- long value = lambda.apply(param.getLong());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ public MultiFloatValueInFloatValueOutFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateStreamInDateStreamOutFunction extends AbstractDateValueStream {
- private final DateValueStream param;
- private final LongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ protected boolean exists = false;
+ protected float temp;
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- public DateStreamInDateStreamOutFunction(String name, LongInLongOutLambda lambda, DateValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamLongs(LongConsumer cons) {
- param.streamLongs(value -> cons.accept(lambda.apply(value)));
- }
+ static class MultiFloatValueInFloatValueOutRequireAllFunction extends MultiFloatValueInFloatValueOutFunction {
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateStreamInDateValueOutFunction extends AbstractDateValue implements LongConsumer {
- private final DateValueStream param;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public DateStreamInDateValueOutFunction(String name, TwoLongInLongOutLambda lambda, DateValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private long value;
-
- @Override
- public long getLong() {
- exists = false;
- param.streamLongs(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(long paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ public MultiFloatValueInFloatValueOutRequireAllFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue[] params) {
+ super(name, lambda, params);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public float getFloat() {
+ float value = params[0].getFloat();
+ exists = params[0].exists();
+ for (int i = 1; i < params.length && exists; ++i) {
+ value = lambda.apply(value, params[i].getFloat());
+ exists = params[i].exists();
+ }
+ return value;
+ }
}
-}
-class TwoDateValueInDateValueOutFunction extends AbstractDateValue {
- private final DateValue param1;
- private final DateValue param2;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public TwoDateValueInDateValueOutFunction(String name, TwoLongInLongOutLambda lambda, DateValue param1, DateValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class MultiFloatValueInFloatValueOutRequireOneFunction extends MultiFloatValueInFloatValueOutFunction {
- private boolean exists = false;
+ public MultiFloatValueInFloatValueOutRequireOneFunction(String name, TwoFloatInFloatOutLambda lambda, FloatValue[] params) {
+ super(name, lambda, params);
+ }
- @Override
- public long getLong() {
- long value = lambda.apply(param1.getLong(), param2.getLong());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public float getFloat() {
+ int i = -1;
+ float value = 0;
+ exists = false;
+ while (++i < params.length) {
+ value = params[i].getFloat();
+ exists = params[i].exists();
+ if (exists) {
+ break;
+ }
+ }
+ while (++i < params.length) {
+ temp = params[i].getFloat();
+ if (params[i].exists()) {
+ value = lambda.apply(value, temp);
+ }
+ }
+ return value;
+ }
}
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class DateValueDateStreamInDateStreamOutFunction extends AbstractDateValueStream {
- private final DateValue param1;
- private final DateValueStream param2;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class DoubleValueInDoubleValueOutFunction extends AbstractDoubleValue {
+ private final DoubleValue param;
+ private final DoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- public DateValueDateStreamInDateStreamOutFunction(String name, TwoLongInLongOutLambda lambda, DateValue param1, DateValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ public DoubleValueInDoubleValueOutFunction(String name, DoubleInDoubleOutLambda lambda, DoubleValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ private boolean exists = false;
- @Override
- public void streamLongs(LongConsumer cons) {
- long value1 = param1.getLong();
- if (param1.exists()) {
- param2.streamLongs(value2 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public double getDouble() {
+ double value = lambda.apply(param.getDouble());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class DateStreamDateValueInDateStreamOutFunction extends AbstractDateValueStream {
- private final DateValueStream param1;
- private final DateValue param2;
- private final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public DateStreamDateValueInDateStreamOutFunction(String name, TwoLongInLongOutLambda lambda, DateValueStream param1, DateValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class DoubleStreamInDoubleStreamOutFunction extends AbstractDoubleValueStream {
+ private final DoubleValueStream param;
+ private final DoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public void streamLongs(LongConsumer cons) {
- long value2 = param2.getLong();
- if (param2.exists()) {
- param1.streamLongs(value1 -> cons.accept(lambda.apply(value1,value2)));
+ public DoubleStreamInDoubleStreamOutFunction(String name, DoubleInDoubleOutLambda lambda, DoubleValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-abstract class MultiDateValueInDateValueOutFunction extends AbstractDateValue {
- protected final DateValue[] params;
- protected final TwoLongInLongOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ @Override
+ public void streamDoubles(DoubleConsumer cons) {
+ param.streamDoubles(value -> cons.accept(lambda.apply(value)));
+ }
- public MultiDateValueInDateValueOutFunction(String name, TwoLongInLongOutLambda lambda, DateValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- protected boolean exists = false;
- protected long temp;
- @Override
- public boolean exists() {
- return exists;
- }
+ static class DoubleStreamInDoubleValueOutFunction extends AbstractDoubleValue implements DoubleConsumer {
+ private final DoubleValueStream param;
+ private final TwoDoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class MultiDateValueInDateValueOutRequireAllFunction extends MultiDateValueInDateValueOutFunction {
+ public DoubleStreamInDoubleValueOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- public MultiDateValueInDateValueOutRequireAllFunction(String name, TwoLongInLongOutLambda lambda, DateValue[] params) {
- super(name, lambda, params);
- }
+ private boolean exists = false;
+ private double value;
- @Override
- public long getLong() {
- long value = params[0].getLong();
- exists = params[0].exists();
- for (int i = 1; i < params.length && exists; ++i) {
- value = lambda.apply(value, params[i].getLong());
- exists = params[i].exists();
+ @Override
+ public double getDouble() {
+ exists = false;
+ param.streamDoubles(this);
+ return value;
}
- return value;
- }
-}
-class MultiDateValueInDateValueOutRequireOneFunction extends MultiDateValueInDateValueOutFunction {
-
- public MultiDateValueInDateValueOutRequireOneFunction(String name, TwoLongInLongOutLambda lambda, DateValue[] params) {
- super(name, lambda, params);
- }
-
- @Override
- public long getLong() {
- int i = -1;
- long value = 0;
- exists = false;
- while (++i < params.length) {
- value = params[i].getLong();
- exists = params[i].exists();
- if (exists) {
- break;
- }
+ @Override
+ public boolean exists() {
+ return exists;
}
- while (++i < params.length) {
- temp = params[i].getLong();
- if (params[i].exists()) {
- value = lambda.apply(value, temp);
+ public void accept(double paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
}
}
- return value;
- }
-}
-class StringValueInStringValueOutFunction extends AbstractStringValue {
- private final StringValue param;
- private final StringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public StringValueInStringValueOutFunction(String name, StringInStringOutLambda lambda, StringValue param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- private boolean exists = false;
+ static class TwoDoubleValueInDoubleValueOutFunction extends AbstractDoubleValue {
+ private final DoubleValue param1;
+ private final DoubleValue param2;
+ private final TwoDoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoDoubleValueInDoubleValueOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue param1, DoubleValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- @Override
- public String getString() {
- String value = lambda.apply(param.getString());
- exists = param.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
+ private boolean exists = false;
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class StringStreamInStringStreamOutFunction extends AbstractStringValueStream {
- private final StringValueStream param;
- private final StringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ @Override
+ public double getDouble() {
+ double value = lambda.apply(param1.getDouble(), param2.getDouble());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
- public StringStreamInStringStreamOutFunction(String name, StringInStringOutLambda lambda, StringValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamStrings(Consumer<String> cons) {
- param.streamStrings(value -> cons.accept(lambda.apply(value)));
- }
+ static class DoubleValueDoubleStreamInDoubleStreamOutFunction extends AbstractDoubleValueStream {
+ private final DoubleValue param1;
+ private final DoubleValueStream param2;
+ private final TwoDoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DoubleValueDoubleStreamInDoubleStreamOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue param1, DoubleValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
- }
-}
-class StringStreamInStringValueOutFunction extends AbstractStringValue implements Consumer<String> {
- private final StringValueStream param;
- private final TwoStringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
-
- public StringStreamInStringValueOutFunction(String name, TwoStringInStringOutLambda lambda, StringValueStream param) {
- this.name = name;
- this.lambda = lambda;
- this.param = param;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
- }
-
- private boolean exists = false;
- private String value;
-
- @Override
- public String getString() {
- exists = false;
- param.streamStrings(this);
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
- }
- public void accept(String paramValue) {
- if (!exists) {
- exists = true;
- value = paramValue;
- } else {
- value = lambda.apply(value, paramValue);
+ @Override
+ public void streamDoubles(DoubleConsumer cons) {
+ double value1 = param1.getDouble();
+ if (param1.exists()) {
+ param2.streamDoubles(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
}
- }
- @Override
- public String getName() {
- return name;
- }
- @Override
- public String getExpressionStr() {
- return exprStr;
- }
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class TwoStringValueInStringValueOutFunction extends AbstractStringValue {
- private final StringValue param1;
- private final StringValue param2;
- private final TwoStringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
- public TwoStringValueInStringValueOutFunction(String name, TwoStringInStringOutLambda lambda, StringValue param1, StringValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
- }
+ static class DoubleStreamDoubleValueInDoubleStreamOutFunction extends AbstractDoubleValueStream {
+ private final DoubleValueStream param1;
+ private final DoubleValue param2;
+ private final TwoDoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DoubleStreamDoubleValueInDoubleStreamOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValueStream param1, DoubleValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- private boolean exists = false;
+ @Override
+ public void streamDoubles(DoubleConsumer cons) {
+ double value2 = param2.getDouble();
+ if (param2.exists()) {
+ param1.streamDoubles(value1 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
- @Override
- public String getString() {
- String value = lambda.apply(param1.getString(), param2.getString());
- exists = param1.exists() && param2.exists();
- return value;
- }
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getName() {
- return name;
+ abstract static class MultiDoubleValueInDoubleValueOutFunction extends AbstractDoubleValue {
+ protected final DoubleValue[] params;
+ protected final TwoDoubleInDoubleOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public MultiDoubleValueInDoubleValueOutFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
+
+ protected boolean exists = false;
+ protected double temp;
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getExpressionStr() {
- return exprStr;
+
+ static class MultiDoubleValueInDoubleValueOutRequireAllFunction extends MultiDoubleValueInDoubleValueOutFunction {
+
+ public MultiDoubleValueInDoubleValueOutRequireAllFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue[] params) {
+ super(name, lambda, params);
+ }
+
+ @Override
+ public double getDouble() {
+ double value = params[0].getDouble();
+ exists = params[0].exists();
+ for (int i = 1; i < params.length && exists; ++i) {
+ value = lambda.apply(value, params[i].getDouble());
+ exists = params[i].exists();
+ }
+ return value;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+
+ static class MultiDoubleValueInDoubleValueOutRequireOneFunction extends MultiDoubleValueInDoubleValueOutFunction {
+
+ public MultiDoubleValueInDoubleValueOutRequireOneFunction(String name, TwoDoubleInDoubleOutLambda lambda, DoubleValue[] params) {
+ super(name, lambda, params);
+ }
+
+ @Override
+ public double getDouble() {
+ int i = -1;
+ double value = 0;
+ exists = false;
+ while (++i < params.length) {
+ value = params[i].getDouble();
+ exists = params[i].exists();
+ if (exists) {
+ break;
+ }
+ }
+ while (++i < params.length) {
+ temp = params[i].getDouble();
+ if (params[i].exists()) {
+ value = lambda.apply(value, temp);
+ }
+ }
+ return value;
+ }
}
-}
-class StringValueStringStreamInStringStreamOutFunction extends AbstractStringValueStream {
- private final StringValue param1;
- private final StringValueStream param2;
- private final TwoStringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class DateValueInDateValueOutFunction extends AbstractDateValue {
+ private final DateValue param;
+ private final LongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateValueInDateValueOutFunction(String name, LongInLongOutLambda lambda, DateValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
- public StringValueStringStreamInStringStreamOutFunction(String name, TwoStringInStringOutLambda lambda, StringValue param1, StringValueStream param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ private boolean exists = false;
+
+ @Override
+ public long getLong() {
+ long value = lambda.apply(param.getLong());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
+ static class DateStreamInDateStreamOutFunction extends AbstractDateValueStream {
+ private final DateValueStream param;
+ private final LongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateStreamInDateStreamOutFunction(String name, LongInLongOutLambda lambda, DateValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ param.streamLongs(value -> cons.accept(lambda.apply(value)));
+ }
- @Override
- public void streamStrings(Consumer<String> cons) {
- String value1 = param1.getString();
- if (param1.exists()) {
- param2.streamStrings(value2 -> cons.accept(lambda.apply(value1,value2)));
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
+ static class DateStreamInDateValueOutFunction extends AbstractDateValue implements LongConsumer {
+ private final DateValueStream param;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateStreamInDateValueOutFunction(String name, TwoLongInLongOutLambda lambda, DateValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ private boolean exists = false;
+ private long value;
- @Override
- public String getName() {
- return name;
+ @Override
+ public long getLong() {
+ exists = false;
+ param.streamLongs(this);
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+ public void accept(long paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getExpressionStr() {
- return exprStr;
+ static class TwoDateValueInDateValueOutFunction extends AbstractDateValue {
+ private final DateValue param1;
+ private final DateValue param2;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoDateValueInDateValueOutFunction(String name, TwoLongInLongOutLambda lambda, DateValue param1, DateValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ private boolean exists = false;
+
+ @Override
+ public long getLong() {
+ long value = lambda.apply(param1.getLong(), param2.getLong());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ static class DateValueDateStreamInDateStreamOutFunction extends AbstractDateValueStream {
+ private final DateValue param1;
+ private final DateValueStream param2;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateValueDateStreamInDateStreamOutFunction(String name, TwoLongInLongOutLambda lambda, DateValue param1, DateValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ long value1 = param1.getLong();
+ if (param1.exists()) {
+ param2.streamLongs(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class StringStreamStringValueInStringStreamOutFunction extends AbstractStringValueStream {
- private final StringValueStream param1;
- private final StringValue param2;
- private final TwoStringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class DateStreamDateValueInDateStreamOutFunction extends AbstractDateValueStream {
+ private final DateValueStream param1;
+ private final DateValue param2;
+ private final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public DateStreamDateValueInDateStreamOutFunction(String name, TwoLongInLongOutLambda lambda, DateValueStream param1, DateValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
- public StringStreamStringValueInStringStreamOutFunction(String name, TwoStringInStringOutLambda lambda, StringValueStream param1, StringValue param2) {
- this.name = name;
- this.lambda = lambda;
- this.param1 = param1;
- this.param2 = param2;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ @Override
+ public void streamLongs(LongConsumer cons) {
+ long value2 = param2.getLong();
+ if (param2.exists()) {
+ param1.streamLongs(value1 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public void streamStrings(Consumer<String> cons) {
- String value2 = param2.getString();
- if (param2.exists()) {
- param1.streamStrings(value1 -> cons.accept(lambda.apply(value1,value2)));
+ abstract static class MultiDateValueInDateValueOutFunction extends AbstractDateValue {
+ protected final DateValue[] params;
+ protected final TwoLongInLongOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public MultiDateValueInDateValueOutFunction(String name, TwoLongInLongOutLambda lambda, DateValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
+
+ protected boolean exists = false;
+ protected long temp;
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
}
}
+ static class MultiDateValueInDateValueOutRequireAllFunction extends LambdaFunction.MultiDateValueInDateValueOutFunction {
+
+ public MultiDateValueInDateValueOutRequireAllFunction(String name, TwoLongInLongOutLambda lambda, DateValue[] params) {
+ super(name, lambda, params);
+ }
- @Override
- public String getName() {
- return name;
+ @Override
+ public long getLong() {
+ long value = params[0].getLong();
+ exists = params[0].exists();
+ for (int i = 1; i < params.length && exists; ++i) {
+ value = lambda.apply(value, params[i].getLong());
+ exists = params[i].exists();
+ }
+ return value;
+ }
}
- @Override
- public String getExpressionStr() {
- return exprStr;
+ static class MultiDateValueInDateValueOutRequireOneFunction extends LambdaFunction.MultiDateValueInDateValueOutFunction {
+
+ public MultiDateValueInDateValueOutRequireOneFunction(String name, TwoLongInLongOutLambda lambda, DateValue[] params) {
+ super(name, lambda, params);
+ }
+
+ @Override
+ public long getLong() {
+ int i = -1;
+ long value = 0;
+ exists = false;
+ while (++i < params.length) {
+ value = params[i].getLong();
+ exists = params[i].exists();
+ if (exists) {
+ break;
+ }
+ }
+ while (++i < params.length) {
+ temp = params[i].getLong();
+ if (params[i].exists()) {
+ value = lambda.apply(value, temp);
+ }
+ }
+ return value;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ static class StringValueInStringValueOutFunction extends AbstractStringValue {
+ private final StringValue param;
+ private final StringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringValueInStringValueOutFunction(String name, StringInStringOutLambda lambda, StringValue param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ private boolean exists = false;
+
+ @Override
+ public String getString() {
+ String value = lambda.apply(param.getString());
+ exists = param.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-abstract class MultiStringValueInStringValueOutFunction extends AbstractStringValue {
- protected final StringValue[] params;
- protected final TwoStringInStringOutLambda lambda;
- private final String name;
- private final String exprStr;
- private final ExpressionType funcType;
+ static class StringStreamInStringStreamOutFunction extends AbstractStringValueStream {
+ private final StringValueStream param;
+ private final StringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringStreamInStringStreamOutFunction(String name, StringInStringOutLambda lambda, StringValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ @Override
+ public void streamStrings(Consumer<String> cons) {
+ param.streamStrings(value -> cons.accept(lambda.apply(value)));
+ }
- public MultiStringValueInStringValueOutFunction(String name, TwoStringInStringOutLambda lambda, StringValue[] params) {
- this.name = name;
- this.lambda = lambda;
- this.params = params;
- this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
- this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
+ static class StringStreamInStringValueOutFunction extends AbstractStringValue implements Consumer<String> {
+ private final StringValueStream param;
+ private final TwoStringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringStreamInStringValueOutFunction(String name, TwoStringInStringOutLambda lambda, StringValueStream param) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param = param;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param);
+ }
+
+ private boolean exists = false;
+ private String value;
+
+ @Override
+ public String getString() {
+ exists = false;
+ param.streamStrings(this);
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+ public void accept(String paramValue) {
+ if (!exists) {
+ exists = true;
+ value = paramValue;
+ } else {
+ value = lambda.apply(value, paramValue);
+ }
+ }
- protected boolean exists = false;
- protected String temp = null;
- @Override
- public boolean exists() {
- return exists;
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
+ static class TwoStringValueInStringValueOutFunction extends AbstractStringValue {
+ private final StringValue param1;
+ private final StringValue param2;
+ private final TwoStringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public TwoStringValueInStringValueOutFunction(String name, TwoStringInStringOutLambda lambda, StringValue param1, StringValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ private boolean exists = false;
- @Override
- public String getName() {
- return name;
+ @Override
+ public String getString() {
+ String value = lambda.apply(param1.getString(), param2.getString());
+ exists = param1.exists() && param2.exists();
+ return value;
+ }
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public String getExpressionStr() {
- return exprStr;
+ static class StringValueStringStreamInStringStreamOutFunction extends AbstractStringValueStream {
+ private final StringValue param1;
+ private final StringValueStream param2;
+ private final TwoStringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringValueStringStreamInStringStreamOutFunction(String name, TwoStringInStringOutLambda lambda, StringValue param1, StringValueStream param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ @Override
+ public void streamStrings(Consumer<String> cons) {
+ String value1 = param1.getString();
+ if (param1.exists()) {
+ param2.streamStrings(value2 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
- @Override
- public ExpressionType getExpressionType() {
- return funcType;
+ static class StringStreamStringValueInStringStreamOutFunction extends AbstractStringValueStream {
+ private final StringValueStream param1;
+ private final StringValue param2;
+ private final TwoStringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public StringStreamStringValueInStringStreamOutFunction(String name, TwoStringInStringOutLambda lambda, StringValueStream param1, StringValue param2) {
+ this.name = name;
+ this.lambda = lambda;
+ this.param1 = param1;
+ this.param2 = param2;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,param1,param2);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,param1,param2);
+ }
+
+ @Override
+ public void streamStrings(Consumer<String> cons) {
+ String value2 = param2.getString();
+ if (param2.exists()) {
+ param1.streamStrings(value1 -> cons.accept(lambda.apply(value1,value2)));
+ }
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public String getExpressionStr() {
+ return exprStr;
+ }
+ @Override
+ public ExpressionType getExpressionType() {
+ return funcType;
+ }
}
-}
-class MultiStringValueInStringValueOutRequireAllFunction extends MultiStringValueInStringValueOutFunction {
- public MultiStringValueInStringValueOutRequireAllFunction(String name, TwoStringInStringOutLambda lambda, StringValue[] params) {
- super(name, lambda, params);
+ abstract static class MultiStringValueInStringValueOutFunction extends AbstractStringValue {
+ protected final StringValue[] params;
+ protected final TwoStringInStringOutLambda lambda;
+ private final String name;
+ private final String exprStr;
+ private final ExpressionType funcType;
+
+ public MultiStringValueInStringValueOutFunction(String name, TwoStringInStringOutLambda lambda, StringValue[] params) {
+ this.name = name;
+ this.lambda = lambda;
+ this.params = params;
+ this.exprStr = AnalyticsValueStream.createExpressionString(name,params);
+ this.funcType = AnalyticsValueStream.determineMappingPhase(exprStr,params);
+ }
+
+ protected boolean exists = false;
+ protected String temp = null;
+ @Override
+ public boolean exists() {
+ return exists;
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
... 10355 lines suppressed ...