Moved the algorithm to get the dimensions of a retriever chain to the

FunctionProvider

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

@@ -17,14 +17,12 @@ import com.sap.sse.datamining.DataRetrieverChainDefinition;
 import com.sap.sse.datamining.Query;
 import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.factories.FunctionFactory;
 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.i18n.DataMiningStringMessages;
 import com.sap.sse.datamining.impl.DataMiningActivator;
 import com.sap.sse.datamining.impl.DataRetrieverChainDefinitionRegistry;
-import com.sap.sse.datamining.impl.DataRetrieverTypeWithInformation;
 import com.sap.sse.datamining.impl.ProcessorQuery;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
 import com.sap.sse.datamining.impl.criterias.AndCompoundFilterCriterion;
@@ -38,14 +36,12 @@ import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 public class SailingDataMiningFactory {
 
     private final ProcessorFactory processorFactory;
-    private final FunctionFactory functionFactory;
     
     private final FunctionProvider functionProvider;
     private final DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry;
 
     public SailingDataMiningFactory(FunctionProvider functionProvider, DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry) {
         processorFactory = new ProcessorFactory(DataMiningActivator.getExecutor());
-        functionFactory = new FunctionFactory();
         
         this.functionProvider = functionProvider;
         this.dataRetrieverChainDefinitionRegistry = dataRetrieverChainDefinitionRegistry;
@@ -126,7 +122,7 @@ public class SailingDataMiningFactory {
 
                 DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition = dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinition(RacingEventService.class, dataRetrieverChainDefinitionDTO.getId());
                 DataRetrieverChainBuilder<RacingEventService> chainBuilder = dataRetrieverChainDefinition.startBuilding(DataMiningActivator.getExecutor());
-                Collection<Function<?>> dimensions = getDimensionsOf(dataRetrieverChainDefinition);
+                Collection<Function<?>> dimensions = functionProvider.getMinimizedDimensionsFor(dataRetrieverChainDefinition);
                 Map<Class<?>, Collection<Function<?>>> dimensionsMappedByDeclaringType = mapFunctionsByDeclaringType(dimensions);
                 while (!dimensionsMappedByDeclaringType.isEmpty()) {
                     Class<?> dataType = chainBuilder.getCurrentRetrievedDataType();
@@ -150,39 +146,6 @@ public class SailingDataMiningFactory {
         };
     }
 
-    private Collection<Function<?>> getDimensionsOf(
-            DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition) {
-        Collection<Function<?>> dimensions = new HashSet<>();
-        List<? extends DataRetrieverTypeWithInformation<?, ?>> dataRetrieverTypesWithInformation = dataRetrieverChainDefinition.getDataRetrieverTypesWithInformation();
-        for (int i = dataRetrieverTypesWithInformation.size() - 1; i >= 0; i--) {
-            DataRetrieverTypeWithInformation<?, ?> dataRetrieverTypeWithInformation = dataRetrieverTypesWithInformation.get(i);
-            Collection<Function<?>> dimensionsOfDataType = functionProvider.getDimensionsFor(dataRetrieverTypeWithInformation.getRetrievedDataType());
-            
-            if (!dimensions.isEmpty()) {
-                Map<Function<?>, Function<?>> dimensionsMappedByTrimmedDimensions = trimFirstMethodAndMapOriginal(dimensions);
-                for (Function<?> dimensionOfDataType : dimensionsOfDataType) {
-                    if (dimensionsMappedByTrimmedDimensions.containsKey(dimensionOfDataType)) {
-                        dimensions.remove(dimensionsMappedByTrimmedDimensions.get(dimensionOfDataType));
-                    }
-                }
-            }
-            
-            dimensions.addAll(dimensionsOfDataType);
-        }
-        return dimensions;
-    }
-    
-    private Map<Function<?>, Function<?>> trimFirstMethodAndMapOriginal(Collection<Function<?>> dimensions) {
-        Map<Function<?>, Function<?>> dimensionsMappedByTrimmedDimensions = new HashMap<>();
-        for (Function<?> dimension : dimensions) {
-            Function<?> trimmedDimension = functionFactory.trimFirstMethod(dimension);
-            if (trimmedDimension != null) {
-                dimensionsMappedByTrimmedDimensions.put(trimmedDimension, dimension);
-            }
-        }
-        return dimensionsMappedByTrimmedDimensions;
-    }
-
     private Map<Class<?>, Collection<Function<?>>> mapFunctionsByDeclaringType(Collection<Function<?>> functions) {
         Map<Class<?>, Collection<Function<?>>> mappedFunctions = new HashMap<>();
         for (Function<?> function : functions) {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/functions/TestFunctionProvider.java

@@ -13,12 +13,16 @@ import java.util.Locale;
 import org.junit.Before;
 import org.junit.Test;
 
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
+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.functions.FunctionRegistry;
 import com.sap.sse.datamining.i18n.DataMiningStringMessages;
+import com.sap.sse.datamining.impl.SimpleDataRetrieverChainDefinition;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Named;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Regatta;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegOfCompetitorContext;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegOfCompetitorContextImpl;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContext;
@@ -28,6 +32,9 @@ import com.sap.sse.datamining.test.functions.test_classes.Test_ExternalLibraryCl
 import com.sap.sse.datamining.test.util.ExpectedFunctionRegistryUtil;
 import com.sap.sse.datamining.test.util.FunctionTestsUtil;
 import com.sap.sse.datamining.test.util.TestsUtil;
+import com.sap.sse.datamining.test.util.components.TestLegOfCompetitorWithContextRetrievalProcessor;
+import com.sap.sse.datamining.test.util.components.TestRaceWithContextRetrievalProcessor;
+import com.sap.sse.datamining.test.util.components.TestRegattaRetrievalProcessor;
 
 public class TestFunctionProvider {
     
@@ -71,6 +78,37 @@ public class TestFunctionProvider {
         assertThat(functionProvider.getDimensionsFor(Test_HasLegOfCompetitorContextImpl.class), is(expectedDimensions));
     }
     
+    @Test
+    public void testGetDimensionsForDataRetrieverChainDefinition() {
+        FunctionProvider functionProvider = new RegistryFunctionProvider(functionRegistry);
+        DataRetrieverChainDefinition<Collection<Test_Regatta>> dataRetrieverChainDefinition = createDataRetrieverChainDefinition();
+
+        Collection<Function<?>> expectedDimensions = functionRegistryUtil.getExpectedDimensionsFor(Test_HasRaceContext.class);
+        expectedDimensions.addAll(functionRegistryUtil.getExpectedDimensionsFor(Test_HasLegOfCompetitorContext.class));
+        assertThat(functionProvider.getMinimizedDimensionsFor(dataRetrieverChainDefinition), is(expectedDimensions));
+    }
+    
+    @SuppressWarnings("unchecked")
+    public DataRetrieverChainDefinition<Collection<Test_Regatta>> createDataRetrieverChainDefinition() {
+        DataRetrieverChainDefinition<Collection<Test_Regatta>> dataRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>((Class<Collection<Test_Regatta>>)(Class<?>) Collection.class, "TestRetrieverChain");
+        Class<Processor<Collection<Test_Regatta>, Test_Regatta>> regattaRetrieverClass = (Class<Processor<Collection<Test_Regatta>, Test_Regatta>>)(Class<?>) TestRegattaRetrievalProcessor.class;
+        dataRetrieverChainDefinition.startWith(regattaRetrieverClass, Test_Regatta.class);
+        
+        Class<Processor<Test_Regatta, Test_HasRaceContext>> raceRetrieverClass = 
+                (Class<Processor<Test_Regatta, Test_HasRaceContext>>)(Class<?>) TestRaceWithContextRetrievalProcessor.class;
+        dataRetrieverChainDefinition.addAsLast(regattaRetrieverClass,
+                                               raceRetrieverClass,
+                                               Test_HasRaceContext.class);
+        
+        Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>> legRetrieverClass = 
+                (Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>>)(Class<?>) TestLegOfCompetitorWithContextRetrievalProcessor.class;
+        dataRetrieverChainDefinition.addAsLast(raceRetrieverClass,
+                                               legRetrieverClass,
+                                               Test_HasLegOfCompetitorContext.class);
+        
+        return dataRetrieverChainDefinition;
+    }
+    
     @Test
     public void testGetStatisticsForType() {
         FunctionProvider functionProvider = new RegistryFunctionProvider(functionRegistry);

java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/FunctionProvider.java

@@ -2,6 +2,7 @@ package com.sap.sse.datamining.functions;
 
 import java.util.Collection;
 
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
 public interface FunctionProvider {
@@ -14,6 +15,9 @@ public interface FunctionProvider {
 
     public Collection<Function<?>> getDimensionsFor(Class<?> sourceType);
 
+    public <DataSourceType> Collection<Function<?>> getMinimizedDimensionsFor(
+            DataRetrieverChainDefinition<DataSourceType> dataRetrieverChainDefinition);
+
     /**
      * @return The first function, that matches the given DTO or <code>null</code>
      */

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/RegistryFunctionProvider.java

@@ -2,15 +2,21 @@ package com.sap.sse.datamining.impl.functions;
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
 import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.factories.FunctionDTOFactory;
+import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.functions.FunctionProvider;
 import com.sap.sse.datamining.functions.FunctionRegistry;
+import com.sap.sse.datamining.impl.DataRetrieverTypeWithInformation;
 import com.sap.sse.datamining.impl.functions.criterias.FunctionMatchesDTOFilterCriterion;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
@@ -42,6 +48,7 @@ public class RegistryFunctionProvider implements FunctionProvider {
     
     private static final Logger LOGGER = Logger.getLogger(RegistryFunctionProvider.class.getName());
 
+    private final FunctionFactory functionFactory;
     private final FunctionDTOFactory functionDTOFactory;
     private final Collection<FunctionRegistry> functionRegistries;
 
@@ -50,6 +57,7 @@ public class RegistryFunctionProvider implements FunctionProvider {
     }
     
     public RegistryFunctionProvider(Collection<FunctionRegistry> functionRegistries) {
+        functionFactory = new FunctionFactory();
         functionDTOFactory = new FunctionDTOFactory();
         this.functionRegistries = new HashSet<>(functionRegistries);
     }
@@ -73,6 +81,39 @@ public class RegistryFunctionProvider implements FunctionProvider {
         return getFunctionsFor(sourceType, FunctionRetrievalStrategies.Dimensions);
     }
     
+    @Override
+    public <DataSourceType> Collection<Function<?>> getMinimizedDimensionsFor(DataRetrieverChainDefinition<DataSourceType> dataRetrieverChainDefinition) {
+        Collection<Function<?>> dimensions = new HashSet<>();
+        List<? extends DataRetrieverTypeWithInformation<?, ?>> dataRetrieverTypesWithInformation = dataRetrieverChainDefinition.getDataRetrieverTypesWithInformation();
+        for (int i = dataRetrieverTypesWithInformation.size() - 1; i >= 0; i--) {
+            DataRetrieverTypeWithInformation<?, ?> dataRetrieverTypeWithInformation = dataRetrieverTypesWithInformation.get(i);
+            Collection<Function<?>> dimensionsOfDataType = getDimensionsFor(dataRetrieverTypeWithInformation.getRetrievedDataType());
+            
+            if (!dimensions.isEmpty()) {
+                Map<Function<?>, Function<?>> dimensionsMappedByTrimmedDimensions = trimFirstMethodAndMapOriginal(dimensions);
+                for (Function<?> dimensionOfDataType : dimensionsOfDataType) {
+                    if (dimensionsMappedByTrimmedDimensions.containsKey(dimensionOfDataType)) {
+                        dimensions.remove(dimensionsMappedByTrimmedDimensions.get(dimensionOfDataType));
+                    }
+                }
+            }
+            
+            dimensions.addAll(dimensionsOfDataType);
+        }
+        return dimensions;
+    }
+    
+    private Map<Function<?>, Function<?>> trimFirstMethodAndMapOriginal(Collection<Function<?>> dimensions) {
+        Map<Function<?>, Function<?>> dimensionsMappedByTrimmedDimensions = new HashMap<>();
+        for (Function<?> dimension : dimensions) {
+            Function<?> trimmedDimension = functionFactory.trimFirstMethod(dimension);
+            if (trimmedDimension != null) {
+                dimensionsMappedByTrimmedDimensions.put(trimmedDimension, dimension);
+            }
+        }
+        return dimensionsMappedByTrimmedDimensions;
+    }
+    
     @Override
     public Collection<Function<?>> getStatisticsFor(Class<?> sourceType) {
         return getFunctionsFor(sourceType, FunctionRetrievalStrategies.Statistics);