eclipse-sailing-analytics/sailing-analytics
1
0 Fork 0
mirror of https://github.com/eclipse-sailing-analytics/sailing-analytics.git synced 2026-11-15 06:49:56 +00:00
Code Activity

Introduced ParameterizedFunctions

Browse Source
This commit is contained in:
Lennart Hensler committed 2015-04-16 20:11:05 +02:00
1 parent aab2bd7f8e
commit ce9a332ec9
11 files changed
+128 -72
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

java/com.sap.sailing.polars/src/com/sap/sailing/polars/mining/PolarDataMiner.java
+11 -10
View File
@@ -42,15 +42,16 @@ import com.sap.sailing.domain.common.tracking.GPSFixMoving;
import com.sap.sailing.domain.tracking.TrackedRace;
import com.sap.sailing.polars.impl.CubicEquation;
import com.sap.sailing.polars.regression.NotEnoughDataHasBeenAddedException;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.components.FilterCriterion;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.data.ClusterGroup;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.impl.components.GroupedDataEntry;
import com.sap.sse.datamining.impl.components.ParallelFilteringProcessor;
import com.sap.sse.datamining.impl.components.ParallelMultiDimensionsValueNestingGroupingProcessor;
import com.sap.sse.datamining.impl.functions.SimpleParameterizedFunction;
public class PolarDataMiner {
@@ -125,38 +126,38 @@ public class PolarDataMiner {
Collection<Processor<GroupedDataEntry<GPSFixMovingWithPolarContext>, ?>> movingAverageGrouperResultReceivers = new ArrayList<Processor<GroupedDataEntry<GPSFixMovingWithPolarContext>, ?>>();
movingAverageGrouperResultReceivers.add(movingAverageProcessor);
Collection<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProviders = new ArrayList<>();
Collection<ParameterizedFunction<?>> parameterizedDimensions = new ArrayList<>();
for (Function<?> function : PolarDataDimensionCollectionFactory.getMovingAverageClusterKeyDimensions()) {
dimensionsWithParameterProviders.add(new Pair<Function<?>, ParameterProvider>(function, ParameterProvider.NULL));
parameterizedDimensions.add(new SimpleParameterizedFunction<>(function, ParameterProvider.NULL));
}
Processor<GPSFixMovingWithPolarContext, GroupedDataEntry<GPSFixMovingWithPolarContext>> movingAverageGroupingProcessor = new ParallelMultiDimensionsValueNestingGroupingProcessor<GPSFixMovingWithPolarContext>(
GPSFixMovingWithPolarContext.class, executor, movingAverageGrouperResultReceivers, dimensionsWithParameterProviders);
GPSFixMovingWithPolarContext.class, executor, movingAverageGrouperResultReceivers, parameterizedDimensions);
cubicRegressionPerCourseProcessor = new CubicRegressionPerCourseProcessor();
Collection<Processor<GroupedDataEntry<GPSFixMovingWithPolarContext>, ?>> regressionPerCourseGrouperResultReceivers = new ArrayList<Processor<GroupedDataEntry<GPSFixMovingWithPolarContext>, ?>>();
regressionPerCourseGrouperResultReceivers.add(cubicRegressionPerCourseProcessor);
Collection<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProvidersForCubicRegression = new ArrayList<>();
Collection<ParameterizedFunction<?>> parameterizedDimensionsForCubicRegression = new ArrayList<>();
for (Function<?> function : PolarDataDimensionCollectionFactory.getCubicRegressionPerCourseClusterKeyDimensions()) {
dimensionsWithParameterProvidersForCubicRegression.add(new Pair<Function<?>, ParameterProvider>(function, ParameterProvider.NULL));
parameterizedDimensionsForCubicRegression.add(new SimpleParameterizedFunction<>(function, ParameterProvider.NULL));
}
Processor<GPSFixMovingWithPolarContext, GroupedDataEntry<GPSFixMovingWithPolarContext>> cubicRegressionPerCourseGroupingProcessor = new ParallelMultiDimensionsValueNestingGroupingProcessor<GPSFixMovingWithPolarContext>(
GPSFixMovingWithPolarContext.class, executor, regressionPerCourseGrouperResultReceivers, dimensionsWithParameterProvidersForCubicRegression);
GPSFixMovingWithPolarContext.class, executor, regressionPerCourseGrouperResultReceivers, parameterizedDimensionsForCubicRegression);
ClusterGroup<Bearing> angleClusterGroup = createAngleClusterGroup();
speedRegressionPerAngleClusterProcessor = new SpeedRegressionPerAngleClusterProcessor(angleClusterGroup);
Collection<Processor<GroupedDataEntry<GPSFixMovingWithPolarContext>, ?>> regressionPerAngleClusterGrouperResultReceivers = new ArrayList<Processor<GroupedDataEntry<GPSFixMovingWithPolarContext>, ?>>();
regressionPerAngleClusterGrouperResultReceivers.add(speedRegressionPerAngleClusterProcessor);
Collection<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProvidersForRegressionPerAngleCluster = new ArrayList<>();
Collection<ParameterizedFunction<?>> parameterizedDimensionsForRegressionPerAngleCluster = new ArrayList<>();
for (Function<?> function : PolarDataDimensionCollectionFactory.getSpeedRegressionPerAngleClusterClusterKeyDimensions()) {
dimensionsWithParameterProvidersForRegressionPerAngleCluster.add(new Pair<Function<?>, ParameterProvider>(function, ParameterProvider.NULL));
parameterizedDimensionsForRegressionPerAngleCluster.add(new SimpleParameterizedFunction<>(function, ParameterProvider.NULL));
}
Processor<GPSFixMovingWithPolarContext, GroupedDataEntry<GPSFixMovingWithPolarContext>> regressionPerAngleClusterGroupingProcessor = new ParallelMultiDimensionsValueNestingGroupingProcessor<GPSFixMovingWithPolarContext>(
GPSFixMovingWithPolarContext.class, executor, regressionPerAngleClusterGrouperResultReceivers, dimensionsWithParameterProvidersForRegressionPerAngleCluster);
GPSFixMovingWithPolarContext.class, executor, regressionPerAngleClusterGrouperResultReceivers, parameterizedDimensionsForRegressionPerAngleCluster);
Collection<Processor<GPSFixMovingWithPolarContext, ?>> filteringResultReceivers = new ArrayList<>();
java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/TestDimensionsValuesQuery.java
+11 -10
View File
@@ -14,14 +14,15 @@ import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.DataRetrieverChainBuilder;
import com.sap.sse.datamining.DataRetrieverChainDefinition;
import com.sap.sse.datamining.Query;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.impl.components.GroupedDataEntry;
import com.sap.sse.datamining.impl.functions.SimpleParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.datamining.shared.QueryResult;
import com.sap.sse.datamining.shared.dto.FunctionDTO;
@@ -75,16 +76,16 @@ public class TestDimensionsValuesQuery {
protected Processor<Collection<Test_Regatta>, ?> createFirstProcessor() {
Processor<GroupedDataEntry<Object>, Map<GroupKey, Set<Object>>> resultCollector = ComponentTestsUtil.getProcessorFactory().createGroupedDataCollectingAsSetProcessor(this);
Collection<Pair<Function<?>, ParameterProvider>> legDimensions = new ArrayList<>();
legDimensions.add(new Pair<>(dimensionLegNumber, ParameterProvider.NULL));
legDimensions.add(new Pair<>(dimensionCompetitorName, ParameterProvider.NULL));
legDimensions.add(new Pair<>(dimensionCompetitorSailID, ParameterProvider.NULL));
Collection<ParameterizedFunction<?>> legDimensions = new ArrayList<>();
legDimensions.add(new SimpleParameterizedFunction<>(dimensionLegNumber, ParameterProvider.NULL));
legDimensions.add(new SimpleParameterizedFunction<>(dimensionCompetitorName, ParameterProvider.NULL));
legDimensions.add(new SimpleParameterizedFunction<>(dimensionCompetitorSailID, ParameterProvider.NULL));
Collection<Pair<Function<?>, ParameterProvider>> raceDimensions = new ArrayList<>();
raceDimensions.add(new Pair<>(dimensionRegattaName, ParameterProvider.NULL));
raceDimensions.add(new Pair<>(dimensionRaceName, ParameterProvider.NULL));
raceDimensions.add(new Pair<>(dimensionBoatClassName, ParameterProvider.NULL));
raceDimensions.add(new Pair<>(dimensionYear, ParameterProvider.NULL));
Collection<ParameterizedFunction<?>> raceDimensions = new ArrayList<>();
raceDimensions.add(new SimpleParameterizedFunction<>(dimensionRegattaName, ParameterProvider.NULL));
raceDimensions.add(new SimpleParameterizedFunction<>(dimensionRaceName, ParameterProvider.NULL));
raceDimensions.add(new SimpleParameterizedFunction<>(dimensionBoatClassName, ParameterProvider.NULL));
raceDimensions.add(new SimpleParameterizedFunction<>(dimensionYear, ParameterProvider.NULL));
DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor());
chainBuilder.stepFurther(); //Initialization
java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/TestProcessorQuery.java
+4 -3
View File
@@ -21,7 +21,6 @@ import java.util.logging.Logger;
import org.junit.Test;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.AdditionalQueryData;
import com.sap.sse.datamining.AdditionalResultDataBuilder;
import com.sap.sse.datamining.Query;
@@ -31,12 +30,14 @@ import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.factories.ProcessorFactory;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.impl.components.AbstractProcessorInstruction;
import com.sap.sse.datamining.impl.components.AbstractSimpleParallelProcessor;
import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
import com.sap.sse.datamining.impl.components.GroupedDataEntry;
import com.sap.sse.datamining.impl.components.ParallelFilteringProcessor;
import com.sap.sse.datamining.impl.criterias.AbstractFilterCriterion;
import com.sap.sse.datamining.impl.functions.SimpleParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.datamining.shared.QueryResult;
import com.sap.sse.datamining.shared.QueryResultState;
@@ -122,9 +123,9 @@ public class TestProcessorQuery {
Function<Double> getCrossSumFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getCrossSumMethod);
Processor<GroupedDataEntry<Number>, GroupedDataEntry<Double>> crossSumExtractor = processorFactory.createExtractionProcessor(sumAggregator, getCrossSumFunction, ParameterProvider.NULL);
List<Pair<Function<?>, ParameterProvider>> dimensions = new ArrayList<>();
List<ParameterizedFunction<?>> dimensions = new ArrayList<>();
Function<Integer> getLengthFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(Number.class, "getLength"));
dimensions.add(new Pair<>(getLengthFunction, ParameterProvider.NULL));
dimensions.add(new SimpleParameterizedFunction<>(getLengthFunction, ParameterProvider.NULL));
Processor<Number, GroupedDataEntry<Number>> lengthGrouper = processorFactory.createGroupingProcessor(Number.class, crossSumExtractor, dimensions);
Collection<Processor<Number, ?>> filtrationResultReceivers = new ArrayList<>();
filtrationResultReceivers.add(lengthGrouper);
java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestParallelMultiDimensionalGroupingProcessor.java
+8 -8
View File
@@ -11,12 +11,12 @@ import java.util.List;
import org.junit.Before;
import org.junit.Test;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.factories.ProcessorFactory;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.impl.functions.MethodWrappingFunction;
import com.sap.sse.datamining.impl.functions.SimpleParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.datamining.shared.impl.GenericGroupKey;
import com.sap.sse.datamining.shared.impl.NestingCompoundGroupKey;
@@ -48,9 +48,9 @@ public class TestParallelMultiDimensionalGroupingProcessor {
receivers = new ArrayList<>();
receivers.add(receiver);
List<Pair<Function<?>, ParameterProvider>> dimensions = new ArrayList<>();
dimensions.add(new Pair<>(new MethodWrappingFunction<>(Number.class.getMethod("getLength", new Class<?>[0]), int.class), ParameterProvider.NULL));
dimensions.add(new Pair<>(new MethodWrappingFunction<>(Number.class.getMethod("getCrossSum", new Class<?>[0]), int.class), ParameterProvider.NULL));
List<ParameterizedFunction<?>> dimensions = new ArrayList<>();
dimensions.add(new SimpleParameterizedFunction<>(new MethodWrappingFunction<>(Number.class.getMethod("getLength", new Class<?>[0]), int.class), ParameterProvider.NULL));
dimensions.add(new SimpleParameterizedFunction<>(new MethodWrappingFunction<>(Number.class.getMethod("getCrossSum", new Class<?>[0]), int.class), ParameterProvider.NULL));
processor = ComponentTestsUtil.getProcessorFactory().createGroupingProcessor(Number.class, receivers, dimensions);
}
@@ -62,15 +62,15 @@ public class TestParallelMultiDimensionalGroupingProcessor {
@Test(expected=IllegalArgumentException.class)
public void testConstructionWithEmptyDimensions() {
List<Pair<Function<?>, ParameterProvider>> dimensions = new ArrayList<>();
List<ParameterizedFunction<?>> dimensions = new ArrayList<>();
processorFactory.createGroupingProcessor(Number.class, receivers, dimensions);
}
@Test(expected=IllegalArgumentException.class)
public void testConstructionWithFunctionsInsteadOfDimensions() {
List<Pair<Function<?>, ParameterProvider>> functions = new ArrayList<>();
List<ParameterizedFunction<?>> functions = new ArrayList<>();
Method method = FunctionTestsUtil.getMethodFromSimpleClassWithMarkedMethod("sideEffectFreeValue");
functions.add(new Pair<>(FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(method), ParameterProvider.NULL));
functions.add(new SimpleParameterizedFunction<>(FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(method), ParameterProvider.NULL));
processorFactory.createGroupingProcessor(Number.class, receivers, functions);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/factories/ProcessorFactory.java
+15 -12
View File
@@ -8,18 +8,18 @@ import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.impl.ProcessorQuery;
import com.sap.sse.datamining.impl.components.GroupedDataEntry;
import com.sap.sse.datamining.impl.components.ParallelByDimensionGroupingProcessor;
import com.sap.sse.datamining.impl.components.ParallelGroupedElementsValueExtractionProcessor;
import com.sap.sse.datamining.impl.components.ParallelMultiDimensionsValueNestingGroupingProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDataCollectingAsSetProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDoubleDataAverageAggregationProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDataCountAggregationProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDoubleDataAverageAggregationProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDoubleDataMaxAggregationProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDoubleDataMedianAggregationProcessor;
import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDoubleDataMinAggregationProcessor;
@@ -101,18 +101,21 @@ public class ProcessorFactory {
/**
* Creates a grouping processor with the given extraction processor as result receiver.
*/
public <DataType> Processor<DataType, GroupedDataEntry<DataType>> createGroupingProcessor(Class<DataType> dataType, Processor<GroupedDataEntry<DataType>, ?> extractionProcessor, Iterable<Pair<Function<?>, ParameterProvider>> dimensionsToGroupByWithParameterProvider) {
public <DataType> Processor<DataType, GroupedDataEntry<DataType>> createGroupingProcessor(Class<DataType> dataType, Processor<GroupedDataEntry<DataType>, ?> extractionProcessor,
Iterable<ParameterizedFunction<?>> parameterizedDimensions) {
Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers = new ArrayList<>();
resultReceivers.add(extractionProcessor);
return createGroupingProcessor(dataType, resultReceivers, dimensionsToGroupByWithParameterProvider);
return createGroupingProcessor(dataType, resultReceivers, parameterizedDimensions);
}
public <DataType> Processor<DataType, GroupedDataEntry<DataType>> createGroupingProcessor(Class<DataType> dataType, Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers, Iterable<Pair<Function<?>, ParameterProvider>> dimensionsToGroupByWithParameterProvider) {
return new ParallelMultiDimensionsValueNestingGroupingProcessor<>(dataType, executor, resultReceivers, dimensionsToGroupByWithParameterProvider);
public <DataType> Processor<DataType, GroupedDataEntry<DataType>> createGroupingProcessor(Class<DataType> dataType, Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers,
Iterable<ParameterizedFunction<?>> parameterizedDimensions) {
return new ParallelMultiDimensionsValueNestingGroupingProcessor<>(dataType, executor, resultReceivers, parameterizedDimensions);
}
public <DataType> Processor<DataType, GroupedDataEntry<DataType>> createGroupingProcessorWithParameter(Class<DataType> dataType, Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers, List<Pair<Function<?>, ParameterProvider>> dimensionsToGroupByWithParameterProvider) {
return new ParallelMultiDimensionsValueNestingGroupingProcessor<DataType>(dataType, executor, resultReceivers, dimensionsToGroupByWithParameterProvider);
public <DataType> Processor<DataType, GroupedDataEntry<DataType>> createGroupingProcessorWithParameter(Class<DataType> dataType, Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers,
List<ParameterizedFunction<?>> parameterizedDimensions) {
return new ParallelMultiDimensionsValueNestingGroupingProcessor<DataType>(dataType, executor, resultReceivers, parameterizedDimensions);
}
/**
@@ -120,18 +123,18 @@ public class ProcessorFactory {
*/
@SuppressWarnings("unchecked")
public <DataType> Collection<Processor<DataType, GroupedDataEntry<DataType>>> createGroupingExtractorsForDimensions(Class<DataType> dataType,
Processor<GroupedDataEntry<Object>, ?> valueCollector, Iterable<Pair<Function<?>, ParameterProvider>> dimensionsToGroupByWithParameterProvider,
Processor<GroupedDataEntry<Object>, ?> valueCollector, Iterable<ParameterizedFunction<?>> parameterizedDimensions,
ResourceBundleStringMessages stringMessages, Locale locale) {
Collection<Processor<GroupedDataEntry<Object>, ?>> extractionResultReceivers = new ArrayList<>();
extractionResultReceivers.add(valueCollector);
Collection<Processor<DataType, GroupedDataEntry<DataType>>> groupingExtractors = new ArrayList<>();
for (Pair<Function<?>, ParameterProvider> dimensionWithParameterProvider : dimensionsToGroupByWithParameterProvider) {
Processor<GroupedDataEntry<DataType>, GroupedDataEntry<Object>> dimensionValueExtractor = createExtractionProcessor(extractionResultReceivers, (Function<Object>) dimensionWithParameterProvider.getA(), dimensionWithParameterProvider.getB());
for (ParameterizedFunction<?> parameterizedDimension : parameterizedDimensions) {
Processor<GroupedDataEntry<DataType>, GroupedDataEntry<Object>> dimensionValueExtractor = createExtractionProcessor(extractionResultReceivers, (Function<Object>) parameterizedDimension.getFunction(), parameterizedDimension.getParameterProvider());
Collection<Processor<GroupedDataEntry<DataType>, ?>> groupingResultReceivers = new ArrayList<>();
groupingResultReceivers.add(dimensionValueExtractor);
Processor<DataType, GroupedDataEntry<DataType>> byDimensionGrouper = new ParallelByDimensionGroupingProcessor<>(dataType, executor, groupingResultReceivers, dimensionWithParameterProvider.getA(), stringMessages, locale);
Processor<DataType, GroupedDataEntry<DataType>> byDimensionGrouper = new ParallelByDimensionGroupingProcessor<>(dataType, executor, groupingResultReceivers, parameterizedDimension, stringMessages, locale);
groupingExtractors.add(byDimensionGrouper);
}
return groupingExtractors;
java/com.sap.sse.datamining/src/com/sap/sse/datamining/factories/QueryFactory.java
+6 -5
View File
@@ -10,16 +10,16 @@ import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.DataRetrieverChainBuilder;
import com.sap.sse.datamining.DataRetrieverChainDefinition;
import com.sap.sse.datamining.Query;
import com.sap.sse.datamining.QueryDefinition;
import com.sap.sse.datamining.Query.QueryType;
import com.sap.sse.datamining.QueryDefinition;
import com.sap.sse.datamining.components.FilterCriterion;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.impl.ProcessorQuery;
import com.sap.sse.datamining.impl.SimpleAdditionalQueryData;
import com.sap.sse.datamining.impl.components.GroupedDataEntry;
@@ -27,6 +27,7 @@ import com.sap.sse.datamining.impl.criterias.AndCompoundFilterCriterion;
import com.sap.sse.datamining.impl.criterias.CompoundFilterCriterion;
import com.sap.sse.datamining.impl.criterias.FunctionValuesFilterCriterion;
import com.sap.sse.datamining.impl.functions.LocalizationParameterProvider;
import com.sap.sse.datamining.impl.functions.SimpleParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.i18n.ResourceBundleStringMessages;
@@ -64,10 +65,10 @@ public class QueryFactory {
};
}
private Iterable<Pair<Function<?>, ParameterProvider>> getParameterProvidersFor(Iterable<Function<?>> functions, ResourceBundleStringMessages stringMessages, Locale locale) {
Collection<Pair<Function<?>, ParameterProvider>> functionsWithParameterProvider = new ArrayList<>();
private Iterable<ParameterizedFunction<?>> getParameterProvidersFor(Iterable<Function<?>> functions, ResourceBundleStringMessages stringMessages, Locale locale) {
Collection<ParameterizedFunction<?>> functionsWithParameterProvider = new ArrayList<>();
for (Function<?> function : functions) {
functionsWithParameterProvider.add(new Pair<>(function, getParameterProviderFor(function, stringMessages, locale)));
functionsWithParameterProvider.add(new SimpleParameterizedFunction<>(function, getParameterProviderFor(function, stringMessages, locale)));
}
return functionsWithParameterProvider;
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/ParameterizedFunction.java
+18
View File
@@ -0,0 +1,18 @@
package com.sap.sse.datamining.functions;
import java.lang.reflect.InvocationTargetException;
public interface ParameterizedFunction<ReturnType> {
public Function<ReturnType> getFunction();
public ParameterProvider getParameterProvider();
/**
* Tries to invoke the function for the given <code>instance</code> with parameters of the {@link ParameterProvider}.
*
* @return The result of the function or <code>null</code>, if an {@link InvocationTargetException},
* {@link IllegalAccessException} or {@link IllegalArgumentException} was thrown.
*/
public ReturnType tryToInvoke(Object instance);
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/AbstractParallelMultiDimensionalNestingGroupingProcessor.java
+14 -15
View File
@@ -4,39 +4,39 @@ import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.AdditionalResultDataBuilder;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.datamining.shared.impl.NestingCompoundGroupKey;
public abstract class AbstractParallelMultiDimensionalNestingGroupingProcessor<DataType>
extends AbstractSimpleParallelProcessor<DataType, GroupedDataEntry<DataType>> {
private Iterable<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProvider;
private Iterable<ParameterizedFunction<?>> parameterizedDimensions;
@SuppressWarnings("unchecked")
public AbstractParallelMultiDimensionalNestingGroupingProcessor(Class<DataType> dataType,
ExecutorService executor,
Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers,
Iterable<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProvider) {
Iterable<ParameterizedFunction<?>> parameterizedDimensions) {
super(dataType, (Class<GroupedDataEntry<DataType>>)(Class<?>) GroupedDataEntry.class, executor, resultReceivers);
verifyThatDimensionsAreDimensions(dimensionsWithParameterProvider);
this.dimensionsWithParameterProvider = dimensionsWithParameterProvider;
verifyThatDimensionsAreDimensions(parameterizedDimensions);
this.parameterizedDimensions = parameterizedDimensions;
}
private void verifyThatDimensionsAreDimensions(Iterable<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProvider) {
if (dimensionsWithParameterProvider == null) {
private void verifyThatDimensionsAreDimensions(Iterable<ParameterizedFunction<?>> parameterizedDimensions) {
if (parameterizedDimensions == null) {
throw new IllegalArgumentException("The given dimensions mustn't be null.");
}
int size = 0;
for (Pair<Function<?>, ParameterProvider> possibleDimension : dimensionsWithParameterProvider) {
for (ParameterizedFunction<?> possibleParameterizedDimension : parameterizedDimensions) {
size++;
if (!possibleDimension.getA().isDimension()) {
throw new IllegalArgumentException("The given function " + possibleDimension.getA().toString() + " is no dimension.");
if (!possibleParameterizedDimension.getFunction().isDimension()) {
throw new IllegalArgumentException("The given function " + possibleParameterizedDimension.getFunction().toString() + " is no dimension.");
}
}
@@ -50,15 +50,14 @@ public abstract class AbstractParallelMultiDimensionalNestingGroupingProcessor<D
return new AbstractProcessorInstruction<GroupedDataEntry<DataType>>(this, ProcessorInstructionPriority.Grouping) {
@Override
public GroupedDataEntry<DataType> computeResult() {
return new GroupedDataEntry<DataType>(createCompoundKeyFor(element,
dimensionsWithParameterProvider.iterator()), element);
return new GroupedDataEntry<DataType>(createCompoundKeyFor(element, parameterizedDimensions.iterator()), element);
}
};
}
private GroupKey createCompoundKeyFor(DataType input, Iterator<Pair<Function<?>, ParameterProvider>> dimensionsIterator) {
Pair<Function<?>, ParameterProvider> mainDimension = dimensionsIterator.next();
GroupKey key = createGroupKeyFor(input, mainDimension.getA(), mainDimension.getB());
private GroupKey createCompoundKeyFor(DataType input, Iterator<ParameterizedFunction<?>> dimensionsIterator) {
ParameterizedFunction<?> mainDimension = dimensionsIterator.next();
GroupKey key = createGroupKeyFor(input, mainDimension.getFunction(), mainDimension.getParameterProvider());
if (dimensionsIterator.hasNext()) {
key = new NestingCompoundGroupKey(key, createCompoundKeyFor(input, dimensionsIterator));
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/ParallelByDimensionGroupingProcessor.java
+6 -6
View File
@@ -5,11 +5,11 @@ import java.util.Collection;
import java.util.Locale;
import java.util.concurrent.ExecutorService;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.factories.FunctionDTOFactory;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.datamining.shared.dto.FunctionDTO;
import com.sap.sse.datamining.shared.impl.GenericGroupKey;
@@ -31,18 +31,18 @@ public class ParallelByDimensionGroupingProcessor<DataType> extends
public ParallelByDimensionGroupingProcessor(Class<DataType> dataType,
ExecutorService executor,
Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers,
Function<?> dimension,
ParameterizedFunction<?> parameterizedDimension,
ResourceBundleStringMessages stringMessages, Locale locale) {
super(dataType, executor, resultReceivers, asIterable(dimension));
super(dataType, executor, resultReceivers, asIterable(parameterizedDimension));
this.stringMessages = stringMessages;
this.locale = locale;
functionDTOFactory = new FunctionDTOFactory();
}
private static Iterable<Pair<Function<?>, ParameterProvider>> asIterable(Function<?> dimension) {
Collection<Pair<Function<?>, ParameterProvider>> collection = new ArrayList<>();
collection.add(new Pair<Function<?>, ParameterProvider>(dimension, ParameterProvider.NULL));
private static Iterable<ParameterizedFunction<?>> asIterable(ParameterizedFunction<?> parameterizedDimension) {
Collection<ParameterizedFunction<?>> collection = new ArrayList<>();
collection.add(parameterizedDimension);
return collection;
}
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/ParallelMultiDimensionsValueNestingGroupingProcessor.java
+3 -3
View File
@@ -3,10 +3,10 @@ package com.sap.sse.datamining.impl.components;
import java.util.Collection;
import java.util.concurrent.ExecutorService;
import com.sap.sse.common.Util.Pair;
import com.sap.sse.datamining.components.Processor;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
import com.sap.sse.datamining.shared.GroupKey;
import com.sap.sse.datamining.shared.impl.GenericGroupKey;
@@ -25,8 +25,8 @@ public class ParallelMultiDimensionsValueNestingGroupingProcessor<DataType>
public ParallelMultiDimensionsValueNestingGroupingProcessor(Class<DataType> dataType,
ExecutorService executor,
Collection<Processor<GroupedDataEntry<DataType>, ?>> resultReceivers,
Iterable<Pair<Function<?>, ParameterProvider>> dimensionsWithParameterProvider) {
super(dataType, executor, resultReceivers, dimensionsWithParameterProvider);
Iterable<ParameterizedFunction<?>> parameterizedDimensions) {
super(dataType, executor, resultReceivers, parameterizedDimensions);
}
protected GroupKey createGroupKeyFor(DataType input, Function<?> dimension, ParameterProvider parameterProvider) {
java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/SimpleParameterizedFunction.java
+32
View File
@@ -0,0 +1,32 @@
package com.sap.sse.datamining.impl.functions;
import com.sap.sse.datamining.functions.Function;
import com.sap.sse.datamining.functions.ParameterProvider;
import com.sap.sse.datamining.functions.ParameterizedFunction;
public class SimpleParameterizedFunction<ReturnType> implements ParameterizedFunction<ReturnType> {
private final Function<ReturnType> function;
private final ParameterProvider parameterProvider;
public SimpleParameterizedFunction(Function<ReturnType> function, ParameterProvider parameterProvider) {
this.function = function;
this.parameterProvider = parameterProvider;
}
@Override
public Function<ReturnType> getFunction() {
return function;
}
@Override
public ParameterProvider getParameterProvider() {
return parameterProvider;
}
@Override
public ReturnType tryToInvoke(Object instance) {
return function.tryToInvoke(instance, parameterProvider);
}
}