Integrated the data retriever chain definitions in the backend

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

@@ -2,6 +2,8 @@ package com.sap.sailing.datamining;
 
 import java.util.HashSet;
 import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import org.osgi.framework.BundleActivator;
 import org.osgi.framework.BundleContext;
@@ -12,27 +14,56 @@ import com.sap.sailing.datamining.data.HasTrackedLegContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
 import com.sap.sailing.datamining.data.HasTrackedRaceContext;
 import com.sap.sse.datamining.ClassesWithFunctionsRegistrationService;
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
+import com.sap.sse.datamining.DataRetrieverChainDefinitionRegistrationService;
 
 public class Activator implements BundleActivator {
     
     public static final String dataRetrieverGroupName = "Sailing";
+    private static final Logger LOGGER = Logger.getLogger(Activator.class.getSimpleName());
 
     private static BundleContext context;
-    private ServiceReference<ClassesWithFunctionsRegistrationService> classesWithFunctionsRegistrationServiceReference;
+    private static ServiceReference<ClassesWithFunctionsRegistrationService> classesWithFunctionsRegistrationServiceReference;
+    private static ServiceReference<DataRetrieverChainDefinitionRegistrationService> dataRetrieverChainDefinitionRegistrationServiceServiceReference;
 
     @Override
     public void start(BundleContext context) throws Exception {
         Activator.context = context;
         
         classesWithFunctionsRegistrationServiceReference = Activator.context.getServiceReference(ClassesWithFunctionsRegistrationService.class);
-        Activator.context.getService(classesWithFunctionsRegistrationServiceReference).registerInternalClassesWithMarkedMethods(getInternalClassesWithMarkedMethods());
-        Activator.context.getService(classesWithFunctionsRegistrationServiceReference).registerExternalLibraryClasses(getExternalLibraryClasses());
+        if (classesWithFunctionsRegistrationServiceReference != null) {
+            Activator.context.getService(classesWithFunctionsRegistrationServiceReference)
+                    .registerInternalClassesWithMarkedMethods(getInternalClassesWithMarkedMethods());
+            Activator.context.getService(classesWithFunctionsRegistrationServiceReference)
+                    .registerExternalLibraryClasses(getExternalLibraryClasses());
+        } else {
+            LOGGER.log(Level.WARNING, "Couldn't register the sailing classes with functions. No registration service was available.");
+        }
+        
+        dataRetrieverChainDefinitionRegistrationServiceServiceReference = Activator.context.getServiceReference(DataRetrieverChainDefinitionRegistrationService.class);
+        if (dataRetrieverChainDefinitionRegistrationServiceServiceReference != null) {
+            for (DataRetrieverChainDefinition<?> dataRetrieverChainDefinition : SailingDataRetrieverChainDefinitions.getDataRetrieverChainDefinitions()) {
+                Activator.context.getService(dataRetrieverChainDefinitionRegistrationServiceServiceReference).addDataRetrieverChainDefinition(dataRetrieverChainDefinition);
+            }
+        } else {
+            LOGGER.log(Level.WARNING, "Couldn't register the sailing data retriever chain definitions. No registration service was available.");
+        }
     }
 
     @Override
     public void stop(BundleContext context) throws Exception {
-        Activator.context.getService(classesWithFunctionsRegistrationServiceReference).unregisterAllFunctionsOf(getInternalClassesWithMarkedMethods());
-        Activator.context.getService(classesWithFunctionsRegistrationServiceReference).unregisterAllFunctionsOf(getExternalLibraryClasses());
+        if (classesWithFunctionsRegistrationServiceReference != null) {
+            Activator.context.getService(classesWithFunctionsRegistrationServiceReference).unregisterAllFunctionsOf(
+                    getInternalClassesWithMarkedMethods());
+            Activator.context.getService(classesWithFunctionsRegistrationServiceReference).unregisterAllFunctionsOf(
+                    getExternalLibraryClasses());
+        }
+        
+        if (dataRetrieverChainDefinitionRegistrationServiceServiceReference != null) {
+            for (DataRetrieverChainDefinition<?> dataRetrieverChainDefinition : SailingDataRetrieverChainDefinitions.getDataRetrieverChainDefinitions()) {
+                Activator.context.getService(dataRetrieverChainDefinitionRegistrationServiceServiceReference).removeDataRetrieverChainDefinition(dataRetrieverChainDefinition);
+            }
+        }
     }
 
     public static Set<Class<?>> getInternalClassesWithMarkedMethods() {

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

@@ -0,0 +1,62 @@
+package com.sap.sailing.datamining;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import com.sap.sailing.datamining.data.HasGPSFixContext;
+import com.sap.sailing.datamining.data.HasTrackedLegContext;
+import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
+import com.sap.sailing.datamining.data.HasTrackedRaceContext;
+import com.sap.sailing.datamining.impl.components.GPSFixRetrievalProcessor;
+import com.sap.sailing.datamining.impl.components.LeaderboardGroupRetrievalProcessor;
+import com.sap.sailing.datamining.impl.components.RegattaLeaderboardFilteringRetrievalProcessor;
+import com.sap.sailing.datamining.impl.components.TrackedLegFilteringRetrievalProcessor;
+import com.sap.sailing.datamining.impl.components.TrackedLegOfCompetitorFilteringRetrievalProcessor;
+import com.sap.sailing.datamining.impl.components.TrackedRaceFilteringRetrievalProcessor;
+import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
+import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
+import com.sap.sailing.server.RacingEventService;
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
+import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.SimpleDataRetrieverChainDefinition;
+
+public class SailingDataRetrieverChainDefinitions {
+    
+    private static Collection<DataRetrieverChainDefinition<?>> dataRetrieverChainDefinitions;
+
+    public static Collection<DataRetrieverChainDefinition<?>> getDataRetrieverChainDefinitions() {
+        if (dataRetrieverChainDefinitions == null) {
+            initializeDataRetrieverChainDefinitions();
+        }
+        return dataRetrieverChainDefinitions;
+    }
+
+    private static void initializeDataRetrieverChainDefinitions() {
+        dataRetrieverChainDefinitions = new ArrayList<>();
+
+        DataRetrieverChainDefinition<RacingEventService> legRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>(RacingEventService.class);
+        @SuppressWarnings("unchecked")
+        Class<Processor<RacingEventService, LeaderboardGroup>> leaderboardGroupRetrieverType = (Class<Processor<RacingEventService, LeaderboardGroup>>)(Class<?>) LeaderboardGroupRetrievalProcessor.class;
+        legRetrieverChainDefinition.startWith(leaderboardGroupRetrieverType, LeaderboardGroup.class);
+        @SuppressWarnings("unchecked")
+        Class<Processor<LeaderboardGroup, RegattaLeaderboard>> regattaLeaderboardRetrieverType = (Class<Processor<LeaderboardGroup, RegattaLeaderboard>>)(Class<?>) RegattaLeaderboardFilteringRetrievalProcessor.class;
+        legRetrieverChainDefinition.addAsLast(leaderboardGroupRetrieverType, regattaLeaderboardRetrieverType, RegattaLeaderboard.class);
+        @SuppressWarnings("unchecked")
+        Class<Processor<RegattaLeaderboard, HasTrackedRaceContext>> raceRetrieverType = (Class<Processor<RegattaLeaderboard, HasTrackedRaceContext>>)(Class<?>) TrackedRaceFilteringRetrievalProcessor.class;
+        legRetrieverChainDefinition.addAsLast(regattaLeaderboardRetrieverType, raceRetrieverType, HasTrackedRaceContext.class);
+        @SuppressWarnings("unchecked")
+        Class<Processor<HasTrackedRaceContext, HasTrackedLegContext>> legRetrieverType = (Class<Processor<HasTrackedRaceContext, HasTrackedLegContext>>)(Class<?>) TrackedLegFilteringRetrievalProcessor.class;
+        legRetrieverChainDefinition.addAsLast(raceRetrieverType, legRetrieverType, HasTrackedLegContext.class);
+        @SuppressWarnings("unchecked")
+        Class<Processor<HasTrackedLegContext, HasTrackedLegOfCompetitorContext>> legOfCompetitorRetrieverType = (Class<Processor<HasTrackedLegContext, HasTrackedLegOfCompetitorContext>>)(Class<?>) TrackedLegOfCompetitorFilteringRetrievalProcessor.class;
+        legRetrieverChainDefinition.addAsLast(legRetrieverType, legOfCompetitorRetrieverType, HasTrackedLegOfCompetitorContext.class);
+        dataRetrieverChainDefinitions.add(legRetrieverChainDefinition);
+        
+        DataRetrieverChainDefinition<RacingEventService> gpsFixRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>(legRetrieverChainDefinition);
+        @SuppressWarnings("unchecked")
+        Class<Processor<HasTrackedLegOfCompetitorContext, HasGPSFixContext>> gpsFixRetrieverType = (Class<Processor<HasTrackedLegOfCompetitorContext, HasGPSFixContext>>)(Class<?>) GPSFixRetrievalProcessor.class;
+        gpsFixRetrieverChainDefinition.addAsLast(legOfCompetitorRetrieverType, gpsFixRetrieverType, HasGPSFixContext.class);
+        dataRetrieverChainDefinitions.add(gpsFixRetrieverChainDefinition);
+    }
+
+}

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/data/HasTrackedLegContext.java

@@ -12,9 +12,9 @@ public interface HasTrackedLegContext {
 
     public TrackedLeg getTrackedLeg();
     
-    @Dimension(messageKey="LegType", ordinal=5)
+    @Dimension(messageKey="LegType", ordinal=6)
     public LegType getLegType();
-    @Dimension(messageKey="LegNumber", ordinal=6)
+    @Dimension(messageKey="LegNumber", ordinal=7)
     public int getLegNumber();
 
 }

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/data/HasTrackedRaceContext.java

@@ -16,19 +16,19 @@ public interface HasTrackedRaceContext {
     @Connector(messageKey="Regatta", ordinal=0)
     public Regatta getRegatta();
     
-    @Connector(messageKey="CourseArea", ordinal=2)
+    @Connector(messageKey="CourseArea", ordinal=3)
     public CourseArea getCourseArea();
     
     @Connector(messageKey="BoatClass", ordinal=1)
     public BoatClass getBoatClass();
     
-    @Connector(messageKey="Fleet", ordinal=3)
+    @Connector(messageKey="Fleet", ordinal=4)
     public Fleet getFleet();
     
-    @Connector(messageKey="Race", ordinal=4)
+    @Connector(messageKey="Race", ordinal=5)
     public RaceDefinition getRace();
     
-    @Dimension(messageKey="Year", ordinal=10)
+    @Dimension(messageKey="Year", ordinal=2)
     public Integer getYear();
 
 }

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

@@ -3,6 +3,8 @@ package com.sap.sailing.datamining.factories;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -10,18 +12,6 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
-import com.sap.sailing.datamining.data.HasGPSFixContext;
-import com.sap.sailing.datamining.data.HasTrackedLegContext;
-import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.datamining.data.HasTrackedRaceContext;
-import com.sap.sailing.datamining.impl.components.GPSFixRetrievalProcessor;
-import com.sap.sailing.datamining.impl.components.LeaderboardGroupRetrievalProcessor;
-import com.sap.sailing.datamining.impl.components.RegattaLeaderboardFilteringRetrievalProcessor;
-import com.sap.sailing.datamining.impl.components.TrackedLegFilteringRetrievalProcessor;
-import com.sap.sailing.datamining.impl.components.TrackedLegOfCompetitorFilteringRetrievalProcessor;
-import com.sap.sailing.datamining.impl.components.TrackedRaceFilteringRetrievalProcessor;
-import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
-import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sse.datamining.DataRetrieverChainBuilder;
 import com.sap.sse.datamining.DataRetrieverChainDefinition;
@@ -33,8 +23,8 @@ 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.ProcessorQuery;
-import com.sap.sse.datamining.impl.SimpleDataRetrieverChainDefinition;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
 import com.sap.sse.datamining.impl.criterias.AndCompoundFilterCriterion;
 import com.sap.sse.datamining.impl.criterias.CompoundFilterCriterion;
@@ -44,39 +34,9 @@ import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
 public class SailingDataMiningFactory {
-    
-    // TODO Remove after the DataRetrieverChainDefinitionProvider has been implemented
-    private final DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition;
-    
-    public SailingDataMiningFactory() {
-        dataRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>(RacingEventService.class);
-        
-        @SuppressWarnings("unchecked")
-        Class<Processor<RacingEventService, LeaderboardGroup>> leaderboardGroupRetrieverType = (Class<Processor<RacingEventService, LeaderboardGroup>>)(Class<?>) LeaderboardGroupRetrievalProcessor.class;
-        dataRetrieverChainDefinition.startWith(leaderboardGroupRetrieverType, LeaderboardGroup.class);
-        
-        @SuppressWarnings("unchecked")
-        Class<Processor<LeaderboardGroup, RegattaLeaderboard>> regattaLeaderboardRetrieverType = (Class<Processor<LeaderboardGroup, RegattaLeaderboard>>)(Class<?>) RegattaLeaderboardFilteringRetrievalProcessor.class;
-        dataRetrieverChainDefinition.addAsLast(leaderboardGroupRetrieverType, regattaLeaderboardRetrieverType, RegattaLeaderboard.class);
 
-        @SuppressWarnings("unchecked")
-        Class<Processor<RegattaLeaderboard, HasTrackedRaceContext>> raceRetrieverType = (Class<Processor<RegattaLeaderboard, HasTrackedRaceContext>>)(Class<?>) TrackedRaceFilteringRetrievalProcessor.class;
-        dataRetrieverChainDefinition.addAsLast(regattaLeaderboardRetrieverType, raceRetrieverType, HasTrackedRaceContext.class);
-
-        @SuppressWarnings("unchecked")
-        Class<Processor<HasTrackedRaceContext, HasTrackedLegContext>> legRetrieverType = (Class<Processor<HasTrackedRaceContext, HasTrackedLegContext>>)(Class<?>) TrackedLegFilteringRetrievalProcessor.class;
-        dataRetrieverChainDefinition.addAsLast(raceRetrieverType, legRetrieverType, HasTrackedLegContext.class);
-
-        @SuppressWarnings("unchecked")
-        Class<Processor<HasTrackedLegContext, HasTrackedLegOfCompetitorContext>> legOfCompetitorRetrieverType = (Class<Processor<HasTrackedLegContext, HasTrackedLegOfCompetitorContext>>)(Class<?>) TrackedLegOfCompetitorFilteringRetrievalProcessor.class;
-        dataRetrieverChainDefinition.addAsLast(legRetrieverType, legOfCompetitorRetrieverType, HasTrackedLegOfCompetitorContext.class);
-
-        @SuppressWarnings("unchecked")
-        Class<Processor<HasTrackedLegOfCompetitorContext, HasGPSFixContext>> gpsFixRetrieverType = (Class<Processor<HasTrackedLegOfCompetitorContext, HasGPSFixContext>>)(Class<?>) GPSFixRetrievalProcessor.class;
-        dataRetrieverChainDefinition.addAsLast(legOfCompetitorRetrieverType, gpsFixRetrieverType, HasGPSFixContext.class);
-    }
-
-    public <ElementType> Query<Double> createQuery(RacingEventService dataSource, final QueryDefinition queryDefinition, final FunctionProvider functionProvider) {
+    public <ElementType> Query<Double> createQuery(RacingEventService dataSource, final QueryDefinition queryDefinition,
+                                                   final FunctionProvider functionProvider, final DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry) {
         return new ProcessorQuery<Double, RacingEventService>(DataMiningActivator.getExecutor(), dataSource,
                 DataMiningActivator.getStringMessages(), DataMiningStringMessages.Util.getLocaleFor(queryDefinition.getLocaleInfoName())) {
             @Override
@@ -91,9 +51,10 @@ public class SailingDataMiningFactory {
                 @SuppressWarnings("unchecked")
                 Processor<ElementType, GroupedDataEntry<ElementType>> groupingProcessor = ProcessorFactory.createGroupingProcessor((Class<ElementType>) extractionFunction.getDeclaringType(), extractionProcessor, dimensionsToGroupBy);
 
+                Class<?> dataTypeToRetrieve = extractionFunction.getDeclaringType();
+                DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition = getDataRetrieverChainDefinition(dataRetrieverChainDefinitionRegistry, dataTypeToRetrieve);
                 DataRetrieverChainBuilder<RacingEventService> chainBuilder = dataRetrieverChainDefinition.startBuilding(DataMiningActivator.getExecutor());
                 Map<Class<?>, FilterCriterion<?>> criteriaMappedByDataType = createFilterCriteria(queryDefinition.getFilterSelection(), functionProvider);
-                Class<?> dataTypeToRetrieve = extractionFunction.getDeclaringType();
                 do {
                     if (criteriaMappedByDataType.containsKey(chainBuilder.getCurrentRetrievedDataType())) {
                         chainBuilder.setFilter(criteriaMappedByDataType.get(chainBuilder.getCurrentRetrievedDataType()));
@@ -132,15 +93,18 @@ public class SailingDataMiningFactory {
         return (Map<Class<?>, FilterCriterion<?>>)(Map<Class<?>, ?>) criteriaMappedByDataType;
     }
 
-    public Query<Set<Object>> createDimensionValuesQuery(RacingEventService dataSource, final Collection<FunctionDTO> dimensionDTOs, final FunctionProvider functionProvider) {
+    public Query<Set<Object>> createDimensionValuesQuery(RacingEventService dataSource, final Collection<FunctionDTO> dimensionDTOs,
+            final FunctionProvider functionProvider, final DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry) {
         return new ProcessorQuery<Set<Object>, RacingEventService>(DataMiningActivator.getExecutor(), dataSource) {
             @Override
             protected Processor<RacingEventService, ?> createFirstProcessor() {
                 Processor<GroupedDataEntry<Object>, Map<GroupKey, Set<Object>>> valueCollector = ProcessorFactory.createGroupedDataCollectingAsSetProcessor(/*query*/ this);
-                
-                DataRetrieverChainBuilder<RacingEventService> chainBuilder = dataRetrieverChainDefinition.startBuilding(DataMiningActivator.getExecutor());
+
                 Collection<Function<?>> dimensions = convertDTOsToFunctions(dimensionDTOs, functionProvider);
+                Class<?> dataTypeToRetrieve = getDeepestDataType(dimensions);
                 Map<Class<?>, Collection<Function<?>>> dimensionsMappedByDeclaringType = mapFunctionsByDeclaringType(dimensions);
+                DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition = getDataRetrieverChainDefinition(dataRetrieverChainDefinitionRegistry, dataTypeToRetrieve);
+                DataRetrieverChainBuilder<RacingEventService> chainBuilder = dataRetrieverChainDefinition.startBuilding(DataMiningActivator.getExecutor());
                 while (!dimensionsMappedByDeclaringType.isEmpty()) {
                     Class<?> dataType = chainBuilder.getCurrentRetrievedDataType();
                     
@@ -182,4 +146,22 @@ public class SailingDataMiningFactory {
         return mappedFunctions;
     }
 
+    protected Class<?> getDeepestDataType(Collection<Function<?>> dimensions) {
+        List<Function<?>> sortedDimensions = new ArrayList<>(dimensions);
+        Collections.sort(sortedDimensions, new Comparator<Function<?>>() {
+            @Override
+            public int compare(Function<?> d1, Function<?> d2) {
+                return Integer.compare(d1.getOrdinal(), d2.getOrdinal());
+            }
+        });
+        return sortedDimensions.get(sortedDimensions.size() - 1).getDeclaringType();
+    }
+
+    private DataRetrieverChainDefinition<RacingEventService> getDataRetrieverChainDefinition(
+            final DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry,
+            Class<?> dataTypeToRetrieve) {
+        // There's currently only one DataRetrieverChainDefinition per possible dataTypeToRetrieve
+        return dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(RacingEventService.class, dataTypeToRetrieve).iterator().next();
+    }
+
 }

java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/base/Competitor.java

@@ -6,10 +6,10 @@ import com.sap.sse.datamining.shared.annotations.Connector;
 import com.sap.sse.common.Named;
 
 public interface Competitor extends Named, WithID, IsManagedBySharedDomainFactory {
-    @Connector(messageKey="Team", ordinal=8)
+    @Connector(messageKey="Team", ordinal=9)
     Team getTeam();
 
-    @Connector(messageKey="Boat", ordinal=9)
+    @Connector(messageKey="Boat", ordinal=10)
     Boat getBoat();
     
     Color getColor();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/DataMiningServiceImpl.java

@@ -96,14 +96,18 @@ public class DataMiningServiceImpl extends RemoteServiceServlet implements DataM
     
     @Override
     public QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception {
-        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), dimensions, getDataMiningServer().getFunctionProvider());
+        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), dimensions,
+                                                                                                      getDataMiningServer().getFunctionProvider(),
+                                                                                                      getDataMiningServer().getDataRetrieverChainDefinitionRegistry());
         return dimensionValuesQuery.run();
     }
 
     @Override
     public <ResultType extends Number> QueryResult<ResultType> runQuery(QueryDefinition queryDefinition) throws Exception {
         @SuppressWarnings("unchecked") // TODO Fix after the data mining has been cleaned
-        Query<ResultType> query = (Query<ResultType>) sailingDataMiningFactory.createQuery(getRacingEventService(), queryDefinition, getDataMiningServer().getFunctionProvider());
+        Query<ResultType> query = (Query<ResultType>) sailingDataMiningFactory.createQuery(getRacingEventService(), queryDefinition,
+                                                                                           getDataMiningServer().getFunctionProvider(),
+                                                                                           getDataMiningServer().getDataRetrieverChainDefinitionRegistry());
         return query.run();
     }
     

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/TestDataRetrieverChainDefinitionRegistry.java

@@ -65,9 +65,30 @@ public class TestDataRetrieverChainDefinitionRegistry {
         expectedDataRetrieverChainDefinitions.add(legRetrieverChainDefinition);
         assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(dataSourceType, Test_HasLegOfCompetitorContext.class), is(expectedDataRetrieverChainDefinitions));
     }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testRemoveDataRetrieverChainDefinition() {
+        Class<Collection<Test_Regatta>> dataSourceType = (Class<Collection<Test_Regatta>>)(Class<?>) Collection.class;
+
+        dataRetrieverChainDefinitionRegistry.remove(legRetrieverChainDefinition);
+        Collection<DataRetrieverChainDefinition<Collection<Test_Regatta>>> expectedEmptyDataRetrieverChainDefinitions = new HashSet<>();
+        assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(dataSourceType, Test_HasLegOfCompetitorContext.class), is(expectedEmptyDataRetrieverChainDefinitions));
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testAddingDataRetrieverChainDefinitionTwice() {
+        Class<Collection<Test_Regatta>> dataSourceType = (Class<Collection<Test_Regatta>>)(Class<?>) Collection.class;
+
+        dataRetrieverChainDefinitionRegistry.add(legRetrieverChainDefinition);
+        Collection<DataRetrieverChainDefinition<Collection<Test_Regatta>>> expectedDataRetrieverChainDefinitions = new HashSet<>();
+        expectedDataRetrieverChainDefinitions.add(legRetrieverChainDefinition);
+        assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(dataSourceType, Test_HasLegOfCompetitorContext.class), is(expectedDataRetrieverChainDefinitions));
+    }
 
     @Test
-    public void testGetDataRetrieverChainDefinitionsForNotRegisteresChain() {
+    public void testGetDataRetrieverChainDefinitionsForNotRegisteredChain() {
         Collection<DataRetrieverChainDefinition<Test_Regatta>> expectedEmptyDataRetrieverChainDefinitions = new HashSet<DataRetrieverChainDefinition<Test_Regatta>>();
         assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(Test_Regatta.class, Test_HasRaceContextImpl.class), is(expectedEmptyDataRetrieverChainDefinitions));
     }

java/com.sap.sse.datamining/src/com/sap/sse/datamining/DataMiningServer.java

@@ -3,13 +3,15 @@ package com.sap.sse.datamining;
 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.DataRetrieverChainDefinitionRegistry;
 
 public interface DataMiningServer {
 
-    public FunctionRegistry getFunctionRegistry();
-
-    public FunctionProvider getFunctionProvider();
-
     public DataMiningStringMessages getStringMessages();
 
+    public FunctionRegistry getFunctionRegistry();
+    public FunctionProvider getFunctionProvider();
+
+    public DataRetrieverChainDefinitionRegistry getDataRetrieverChainDefinitionRegistry();
+
 }

java/com.sap.sse.datamining/src/com/sap/sse/datamining/DataRetrieverChainDefinitionRegistrationService.java

@@ -0,0 +1,8 @@
+package com.sap.sse.datamining;
+
+public interface DataRetrieverChainDefinitionRegistrationService {
+
+    public void addDataRetrieverChainDefinition(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition);
+    public void removeDataRetrieverChainDefinition(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition);
+    
+}

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningActivator.java

@@ -13,13 +13,15 @@ import org.osgi.framework.ServiceRegistration;
 
 import com.sap.sse.datamining.ClassesWithFunctionsRegistrationService;
 import com.sap.sse.datamining.DataMiningServer;
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
+import com.sap.sse.datamining.DataRetrieverChainDefinitionRegistrationService;
 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.functions.RegistryFunctionProvider;
 import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry;
 
-public class DataMiningActivator implements BundleActivator, ClassesWithFunctionsRegistrationService {
+public class DataMiningActivator implements BundleActivator, ClassesWithFunctionsRegistrationService, DataRetrieverChainDefinitionRegistrationService {
 
     private static final int THREAD_POOL_SIZE = Math.max(Runtime.getRuntime().availableProcessors(), 3);
     private static final String STRING_MESSAGES_BASE_NAME = "stringmessages/StringMessages";
@@ -41,15 +43,17 @@ public class DataMiningActivator implements BundleActivator, ClassesWithFunction
 
         FunctionRegistry functionRegistry = new SimpleFunctionRegistry();
         FunctionProvider functionProvider = new RegistryFunctionProvider(functionRegistry);
-        dataMiningServer = new DataMiningServerImpl(stringMessages, functionRegistry, functionProvider);
+        DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry = new SimpleDataRetrieverChainDefinitionRegistry();
+        dataMiningServer = new DataMiningServerImpl(stringMessages, functionRegistry, functionProvider, dataRetrieverChainDefinitionRegistry);
         
         serviceRegistrations = new HashSet<>();
         registerDataMiningServer();
-        registerClassesWithFunctionsRegistrationService();
+        registerRegistrationServices();
     }
 
-    private void registerClassesWithFunctionsRegistrationService() {
+    private void registerRegistrationServices() {
         serviceRegistrations.add(context.registerService(ClassesWithFunctionsRegistrationService.class, this, null));
+        serviceRegistrations.add(context.registerService(DataRetrieverChainDefinitionRegistrationService.class, this, null));
     }
 
     private void registerDataMiningServer() {
@@ -70,6 +74,17 @@ public class DataMiningActivator implements BundleActivator, ClassesWithFunction
     public void unregisterAllFunctionsOf(Set<Class<?>> classesToUnregister) {
         dataMiningServer.getFunctionRegistry().unregisterAllFunctionsOf(classesToUnregister);
     }
+    
+    @Override
+    public void addDataRetrieverChainDefinition(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition) {
+        dataMiningServer.getDataRetrieverChainDefinitionRegistry().add(dataRetrieverChainDefinition);
+    }
+    
+    @Override
+    public void removeDataRetrieverChainDefinition(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition) {
+        dataMiningServer.getDataRetrieverChainDefinitionRegistry().remove(dataRetrieverChainDefinition);
+        
+    }
 
     @Override
     public void stop(BundleContext context) throws Exception {

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningServerImpl.java

@@ -8,13 +8,17 @@ import com.sap.sse.datamining.i18n.DataMiningStringMessages;
 public class DataMiningServerImpl implements DataMiningServer {
     
     private final DataMiningStringMessages stringMessages;
+    
     private final FunctionRegistry functionRegistry;
     private final FunctionProvider functionProvider;
+    
+    private DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry;
 
-    public DataMiningServerImpl(DataMiningStringMessages stringMessages, FunctionRegistry functionRegistry, FunctionProvider functionProvider) {
+    public DataMiningServerImpl(DataMiningStringMessages stringMessages, FunctionRegistry functionRegistry, FunctionProvider functionProvider, DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry) {
         this.stringMessages = stringMessages;
         this.functionRegistry = functionRegistry;
         this.functionProvider = functionProvider;
+        this.dataRetrieverChainDefinitionRegistry = dataRetrieverChainDefinitionRegistry;
     }
 
     @Override
@@ -32,4 +36,9 @@ public class DataMiningServerImpl implements DataMiningServer {
         return stringMessages;
     }
     
+    @Override
+    public DataRetrieverChainDefinitionRegistry getDataRetrieverChainDefinitionRegistry() {
+        return dataRetrieverChainDefinitionRegistry;
+    }
+    
 }

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataRetrieverChainDefinitionRegistry.java

@@ -6,7 +6,8 @@ import com.sap.sse.datamining.DataRetrieverChainDefinition;
 
 public interface DataRetrieverChainDefinitionRegistry {
 
-    public void add(DataRetrieverChainDefinition<?> raceRetrieverChainDefinition);
+    public void add(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition);
+    public void remove(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition);
 
     public <DataSourceType> Collection<DataRetrieverChainDefinition<DataSourceType>> getDataRetrieverChainDefinitions(
             Class<DataSourceType> dataSourceType, Class<?> retrievedDataType);

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/SimpleDataRetrieverChainDefinitionRegistry.java

@@ -17,12 +17,20 @@ public class SimpleDataRetrieverChainDefinitionRegistry implements DataRetriever
     }
 
     @Override
-    public void add(DataRetrieverChainDefinition<?> raceRetrieverChainDefinition) {
-        RegistrationKey key = new RegistrationKey(raceRetrieverChainDefinition.getDataSourceType(), raceRetrieverChainDefinition.getRetrievedDataType());
+    public void add(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition) {
+        RegistrationKey key = new RegistrationKey(dataRetrieverChainDefinition.getDataSourceType(), dataRetrieverChainDefinition.getRetrievedDataType());
         if (!chainDefinitions.containsKey(key)) {
             chainDefinitions.put(key, new HashSet<DataRetrieverChainDefinition<?>>());
         }
-        chainDefinitions.get(key).add(raceRetrieverChainDefinition);
+        chainDefinitions.get(key).add(dataRetrieverChainDefinition);
+    }
+
+    @Override
+    public void remove(DataRetrieverChainDefinition<?> dataRetrieverChainDefinition) {
+        RegistrationKey key = new RegistrationKey(dataRetrieverChainDefinition.getDataSourceType(), dataRetrieverChainDefinition.getRetrievedDataType());
+        if (chainDefinitions.containsKey(key)) {
+            chainDefinitions.get(key).remove(dataRetrieverChainDefinition);
+        }
     }
 
     @SuppressWarnings("unchecked")