Cleaned the query construction process a bit

The convertion from FunctionDTO to Function is now done by the
FunctionProvider and not the DeprecatedToFunctionConverte, because the
transitive functions can now be handled by the FunctionRegistry and
FunctionProvider.

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/QueryDefinitionConverter.java

@@ -3,9 +3,9 @@ package com.sap.sailing.datamining;
 import java.util.Map.Entry;
 
 import com.sap.sailing.datamining.shared.DimensionIdentifier;
-import com.sap.sailing.datamining.shared.QueryDefinition;
 import com.sap.sailing.datamining.shared.QueryDefinitionDeprecated;
-import com.sap.sailing.datamining.shared.impl.QueryDefinitionImpl;
+import com.sap.sse.datamining.shared.QueryDefinition;
+import com.sap.sse.datamining.shared.impl.QueryDefinitionImpl;
 
 public class QueryDefinitionConverter {
 

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/factories/DataMiningFactory.java

@@ -3,18 +3,18 @@ package com.sap.sailing.datamining.factories;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.sap.sailing.datamining.DeprecatedToFunctionConverter;
 import com.sap.sailing.datamining.QueryDefinitionConverter;
 import com.sap.sailing.datamining.data.HasGPSFixContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.datamining.shared.QueryDefinition;
 import com.sap.sailing.datamining.shared.QueryDefinitionDeprecated;
 import com.sap.sse.datamining.Query;
 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.FunctionProvider;
 import com.sap.sse.datamining.impl.ProcessorQuery;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
+import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
 public final class DataMiningFactory {
@@ -23,44 +23,37 @@ public final class DataMiningFactory {
     }
     
     // TODO Delete, after the deprecated components have been removed
-    public static <DataSourceType, ElementType> Query<Double> createQuery(QueryDefinitionDeprecated queryDefinition, DataSourceType dataSource) {
-        return createQuery(QueryDefinitionConverter.convertDeprecatedQueryDefinition(queryDefinition), dataSource);
+    public static <DataSourceType, ElementType> Query<Double> createQuery(QueryDefinitionDeprecated queryDefinition, DataSourceType dataSource, FunctionProvider functionProvider) {
+        return createQuery(QueryDefinitionConverter.convertDeprecatedQueryDefinition(queryDefinition), dataSource, functionProvider);
     }
 
     // TODO Make public, after the deprecated components have been removed
-    private static <DataSourceType, ElementType> Query<Double> createQuery(QueryDefinition queryDefinition, DataSourceType dataSource) {
+    private static <DataSourceType, ElementType> Query<Double> createQuery(QueryDefinition queryDefinition, DataSourceType dataSource, FunctionProvider functionProvider) {
         ProcessorQuery<Double, DataSourceType> query = ProcessorFactory.createProcessorQuery(dataSource, queryDefinition.getLocaleInfoName());
         Processor<GroupedDataEntry<Double>> aggregationProcessor = ProcessorFactory.createAggregationProcessor(query, queryDefinition.getAggregatorType());
         
-        Function<Double> extractionFunction = getExtractionFunction(queryDefinition);
+        @SuppressWarnings("unchecked") // TODO Clean, after the deprecated components have been removed
+        Function<Double> extractionFunction = (Function<Double>) functionProvider.getFunctionForDTO(queryDefinition.getExtractionFunction());
         Processor<GroupedDataEntry<ElementType>> extractionProcessor = ProcessorFactory.createExtractionProcessor(aggregationProcessor, extractionFunction);
         
-        List<Function<?>> dimensionsToGroupBy = getDimensionsToGroupBy(queryDefinition);
+        List<Function<?>> dimensionsToGroupBy = getDimensionsToGroupBy(queryDefinition, functionProvider);
         Processor<ElementType> groupingProcessor = ProcessorFactory.createGroupingProcessor(extractionProcessor, dimensionsToGroupBy);
         
         SailingDataRetrievalLevels dataRetrievalLevel = calculateDataRetrievalLevel(extractionFunction);
-        Processor<DataSourceType> firstRetrievalProcessor = DataRetrieverFactory.createRetrievalProcessorChain(dataRetrievalLevel, groupingProcessor, queryDefinition.getFilterSelection());
+        Processor<DataSourceType> firstRetrievalProcessor = SailingDataRetrieverFactory.createRetrievalProcessorChain(dataRetrievalLevel, groupingProcessor, queryDefinition.getFilterSelection(), functionProvider);
         
         query.setFirstProcessor(firstRetrievalProcessor);
         return query;
     }
 
-    //TODO Get the function from the function provider, not the converter
-    @SuppressWarnings("unchecked") // All extraction functions in the DeprecatedToFunctionConverter have the return type Double
-    private static Function<Double> getExtractionFunction(QueryDefinition queryDefinition) {
-        return (Function<Double>) DeprecatedToFunctionConverter.getFunctionFor(queryDefinition.getExtractionFunction());
-    }
-
-    //TODO Get the functions from the function provider, not the converter
-    private static List<Function<?>> getDimensionsToGroupBy(QueryDefinition queryDefinition) {
+    private static List<Function<?>> getDimensionsToGroupBy(QueryDefinition queryDefinition, FunctionProvider functionProvider) {
         List<Function<?>> dimensionsToGroupBy = new ArrayList<>();
         for (FunctionDTO functionDTO : queryDefinition.getDimensionsToGroupBy()) {
-            dimensionsToGroupBy.add(DeprecatedToFunctionConverter.getFunctionFor(functionDTO));
+            dimensionsToGroupBy.add(functionProvider.getFunctionForDTO(functionDTO));
         }
         return dimensionsToGroupBy;
     }
     
-    //TODO Generalize the way to calculate the base data type from the extraction function
     private static SailingDataRetrievalLevels calculateDataRetrievalLevel(Function<Double> extractionFunction) {
         if (extractionFunction.getDeclaringType().equals(HasGPSFixContext.class)) {
             return SailingDataRetrievalLevels.GPSFix;

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/factories/SailingDataRetrieverFactory.java

@@ -7,7 +7,6 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.ThreadPoolExecutor;
 
-import com.sap.sailing.datamining.DeprecatedToFunctionConverter;
 import com.sap.sailing.datamining.data.HasGPSFixContext;
 import com.sap.sailing.datamining.data.HasTrackedLegContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
@@ -21,6 +20,7 @@ import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
 import com.sap.sse.datamining.components.FilterCriteria;
 import com.sap.sse.datamining.components.Processor;
 import com.sap.sse.datamining.functions.Function;
+import com.sap.sse.datamining.functions.FunctionProvider;
 import com.sap.sse.datamining.impl.DataMiningActivator;
 import com.sap.sse.datamining.impl.criterias.AndCompoundFilterCriteria;
 import com.sap.sse.datamining.impl.criterias.CompoundFilterCriteria;
@@ -28,22 +28,23 @@ import com.sap.sse.datamining.impl.criterias.NonFilteringFilterCriteria;
 import com.sap.sse.datamining.impl.criterias.NullaryFunctionValuesFilterCriteria;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
-public final class DataRetrieverFactory {
+public final class SailingDataRetrieverFactory {
 
-    private DataRetrieverFactory() {
+    private SailingDataRetrieverFactory() {
     }
     
     /**
      * Creates the processor chain for the data retrieval and returns the first processor of the chain.
      * @param groupingProcessor The result receiver after the retrieval
      * @param filterSelection The filter functions and values for the filtration
+     * @param functionProvider 
      * @return The first processor of the retrieval chain.
      */
     @SuppressWarnings("unchecked")
-    public static <DataSourceType, ElementType> Processor<DataSourceType> createRetrievalProcessorChain(SailingDataRetrievalLevels dataRetrievalLevel, Processor<ElementType> groupingProcessor, Map<FunctionDTO, Iterable<?>> filterSelection) {
+    public static <DataSourceType, ElementType> Processor<DataSourceType> createRetrievalProcessorChain(SailingDataRetrievalLevels dataRetrievalLevel, Processor<ElementType> groupingProcessor, Map<FunctionDTO, Iterable<?>> filterSelection, FunctionProvider functionProvider) {
         Processor<?> resultReceiver = groupingProcessor;
         for (int i = dataRetrievalLevel.ordinal(); i <= 0; i--) {
-            resultReceiver = createDataRetrieverFor(SailingDataRetrievalLevels.values()[i], resultReceiver, filterSelection);
+            resultReceiver = createDataRetrieverFor(SailingDataRetrievalLevels.values()[i], resultReceiver, filterSelection, functionProvider);
         }
         return (Processor<DataSourceType>) resultReceiver;
     }
@@ -52,7 +53,7 @@ public final class DataRetrieverFactory {
     /* The way this method is used should guarantee, that the result receiver matches the new processor 
      */
     private static Processor<?> createDataRetrieverFor(SailingDataRetrievalLevels dataRetrievalLevel,
-            Processor<?> resultReceiver, Map<FunctionDTO, Iterable<?>> filterSelection) {
+            Processor<?> resultReceiver, Map<FunctionDTO, Iterable<?>> filterSelection, FunctionProvider functionProvider) {
         ThreadPoolExecutor executor = DataMiningActivator.getExecutor();
         
         switch (dataRetrievalLevel) {
@@ -64,23 +65,23 @@ public final class DataRetrieverFactory {
             return new LeaderboardGroupRetrievalProcessor(executor, Arrays.asList(leaderboardGroupSpecificResultReceiver));
         case RegattaLeaderboard:
             Processor<RegattaLeaderboard> regattaLeaderboardSpecificResultReceiver = (Processor<RegattaLeaderboard>) resultReceiver;
-            return new RegattaLeaderboardFilteringRetrievalProcessor(executor, Arrays.asList(regattaLeaderboardSpecificResultReceiver), getFilterCriteriaForBaseDataType(RegattaLeaderboard.class, filterSelection));
+            return new RegattaLeaderboardFilteringRetrievalProcessor(executor, Arrays.asList(regattaLeaderboardSpecificResultReceiver), getFilterCriteriaForBaseDataType(RegattaLeaderboard.class, filterSelection, functionProvider));
         case TrackedLeg:
             Processor<HasTrackedLegContext> trackedLegSpecificResultReceiver = (Processor<HasTrackedLegContext>) resultReceiver;
-            return new TrackedLegFilteringRetrievalProcessor(executor, Arrays.asList(trackedLegSpecificResultReceiver), getFilterCriteriaForBaseDataType(HasTrackedLegContext.class, filterSelection));
+            return new TrackedLegFilteringRetrievalProcessor(executor, Arrays.asList(trackedLegSpecificResultReceiver), getFilterCriteriaForBaseDataType(HasTrackedLegContext.class, filterSelection, functionProvider));
         case TrackedLegOfCompetitor:
             Processor<HasTrackedLegOfCompetitorContext> trackedLegOfCompetitorSpecificResultReceiver = (Processor<HasTrackedLegOfCompetitorContext>) resultReceiver;
-            return new TrackedLegOfCompetitorFilteringRetrievalProcessor(executor, Arrays.asList(trackedLegOfCompetitorSpecificResultReceiver), getFilterCriteriaForBaseDataType(HasTrackedLegOfCompetitorContext.class, filterSelection));
+            return new TrackedLegOfCompetitorFilteringRetrievalProcessor(executor, Arrays.asList(trackedLegOfCompetitorSpecificResultReceiver), getFilterCriteriaForBaseDataType(HasTrackedLegOfCompetitorContext.class, filterSelection, functionProvider));
         }
         throw new IllegalArgumentException("No data retriever implemented for the given data retrieval level '"
                 + dataRetrievalLevel + "'");
     }
 
     private static <BaseDataType> FilterCriteria<BaseDataType> getFilterCriteriaForBaseDataType(Class<BaseDataType> baseDataType,
-            Map<FunctionDTO, Iterable<?>> filterSelection) {
+            Map<FunctionDTO, Iterable<?>> filterSelection, FunctionProvider functionProvider) {
         CompoundFilterCriteria<BaseDataType> criteria = null;
         for (Entry<FunctionDTO, Iterable<?>> filterSelectionEntry : filterSelection.entrySet()) {
-            Function<?> function = DeprecatedToFunctionConverter.getFunctionFor(filterSelectionEntry.getKey());
+            Function<?> function = functionProvider.getFunctionForDTO(filterSelectionEntry.getKey());
             if (baseDataType.equals(function.getDeclaringType())) {
                 if (criteria == null) {
                     criteria = new AndCompoundFilterCriteria<>();