Merge branch 'master' into axel-usermanagement

Conflicts:
	java/com.sap.sailing.gwt.ui/SailingGWT.launch
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.java
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties
	java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_ru.properties

java/com.sap.sailing.datamining.test/src/com/sap/sailing/datamining/impl/components/TestLeaderboardGroupRetrievalProcessor.java

@@ -6,7 +6,6 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.stub;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -17,17 +16,17 @@ import org.junit.Ignore;
 import org.junit.Test;
 
 import com.sap.sailing.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sailing.datamining.test.util.NullProcessor;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
 import com.sap.sailing.domain.leaderboard.impl.LeaderboardGroupImpl;
 import com.sap.sailing.server.RacingEventService;
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
 
 public class TestLeaderboardGroupRetrievalProcessor {
     
     private RacingEventService service;
-    private Processor<RacingEventService> retriever;
+    private Processor<RacingEventService, LeaderboardGroup> retriever;
     
     private Collection<LeaderboardGroup> retrievedGroups;
     
@@ -37,27 +36,16 @@ public class TestLeaderboardGroupRetrievalProcessor {
         stub(service.getLeaderboardGroups()).toReturn(getGroupsInService());
 
         retrievedGroups = new HashSet<>();
-        Processor<LeaderboardGroup> receiver = new Processor<LeaderboardGroup>() {
+        Processor<LeaderboardGroup, Void> receiver = new NullProcessor<LeaderboardGroup, Void>(LeaderboardGroup.class, Void.class) {
             @Override
             public void processElement(LeaderboardGroup element) {
                 retrievedGroups.add(element);
             }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return null;
-            }
         };
         
-        retriever = new LeaderboardGroupRetrievalProcessor(ConcurrencyTestsUtil.getExecutor(), Arrays.asList(receiver));
+        Collection<Processor<LeaderboardGroup, ?>> resultReceivers = new ArrayList<>();
+        resultReceivers.add(receiver);
+        retriever = new LeaderboardGroupRetrievalProcessor(ConcurrencyTestsUtil.getExecutor(), resultReceivers);
     }
 
     private Map<String, LeaderboardGroup> getGroupsInService() {

java/com.sap.sailing.datamining.test/src/com/sap/sailing/datamining/impl/functions/TestSailingFunctionsRegistration.java

@@ -8,13 +8,13 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 
-import org.junit.BeforeClass;
+import org.junit.Before;
 import org.junit.Test;
 
+import com.sap.sailing.datamining.Activator;
 import com.sap.sailing.datamining.data.HasGPSFixContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
 import com.sap.sailing.datamining.data.HasTrackedRaceContext;
-import com.sap.sailing.datamining.impl.data.SailingDataMiningClassesWithFunctionsService;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Moving;
 import com.sap.sailing.domain.base.Nationality;
@@ -27,15 +27,15 @@ import com.sap.sse.datamining.functions.FunctionRegistry;
 import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry;
 
 public class TestSailingFunctionsRegistration {
+
+    private static FunctionFactory functionFactory = new FunctionFactory();
     
-    private static FunctionRegistry functionRegistry;
+    private FunctionRegistry functionRegistry;
     
-    @BeforeClass
-    public static void setUpFunctionRegistryAndProvider() {
-        SailingDataMiningClassesWithFunctionsService classesWithFunctionsService = new SailingDataMiningClassesWithFunctionsService();
-        
+    @Before
+    public void setUpFunctionRegistryAndProvider() {
         functionRegistry = new SimpleFunctionRegistry();
-        functionRegistry.registerAllWithInternalFunctionPolicy(classesWithFunctionsService.getInternalClassesWithMarkedMethods());
+        functionRegistry.registerAllWithInternalFunctionPolicy(Activator.getInternalClassesWithMarkedMethods());
     }
     
     @Test
@@ -52,23 +52,23 @@ public class TestSailingFunctionsRegistration {
         Collection<Function<?>> expectedDimensions = new HashSet<>();
         
         Method getRegattaMethod = HasTrackedRaceContext.class.getMethod("getRegatta", new Class<?>[0]);
-        Function<?> getRegatta = FunctionFactory.createMethodWrappingFunction(getRegattaMethod);
+        Function<?> getRegatta = functionFactory.createMethodWrappingFunction(getRegattaMethod);
         Method getNameMethod = Named.class.getMethod("getName", new Class<?>[0]);
-        Function<?> getName = FunctionFactory.createMethodWrappingFunction(getNameMethod);
-        expectedDimensions.add(FunctionFactory.createCompoundFunction(Arrays.asList(getRegatta, getName)));
+        Function<?> getName = functionFactory.createMethodWrappingFunction(getNameMethod);
+        expectedDimensions.add(functionFactory.createCompoundFunction(Arrays.asList(getRegatta, getName)));
         
         Method getYearMethod = HasTrackedRaceContext.class.getMethod("getYear", new Class<?>[0]);
-        expectedDimensions.add(FunctionFactory.createMethodWrappingFunction(getYearMethod));
+        expectedDimensions.add(functionFactory.createMethodWrappingFunction(getYearMethod));
         
         Method getCompetitorMethod = HasTrackedLegOfCompetitorContext.class.getMethod("getCompetitor", new Class<?>[0]);
-        Function<?> getCompetitor = FunctionFactory.createMethodWrappingFunction(getCompetitorMethod);
+        Function<?> getCompetitor = functionFactory.createMethodWrappingFunction(getCompetitorMethod);
         Method getTeamMethod = Competitor.class.getMethod("getTeam", new Class<?>[0]);
-        Function<?> getTeam = FunctionFactory.createMethodWrappingFunction(getTeamMethod);
+        Function<?> getTeam = functionFactory.createMethodWrappingFunction(getTeamMethod);
         Method getNationalityMethod = Team.class.getMethod("getNationality", new Class<?>[0]);
-        Function<?> getNationality = FunctionFactory.createMethodWrappingFunction(getNationalityMethod);
+        Function<?> getNationality = functionFactory.createMethodWrappingFunction(getNationalityMethod);
         Method getAcronymMethod = Nationality.class.getMethod("getThreeLetterIOCAcronym", new Class<?>[0]);
-        Function<?> getAcronym = FunctionFactory.createMethodWrappingFunction(getAcronymMethod);
-        expectedDimensions.add(FunctionFactory.createCompoundFunction(Arrays.asList(getCompetitor, getTeam, getNationality, getAcronym)));
+        Function<?> getAcronym = functionFactory.createMethodWrappingFunction(getAcronymMethod);
+        expectedDimensions.add(functionFactory.createCompoundFunction(Arrays.asList(getCompetitor, getTeam, getNationality, getAcronym)));
         
         return expectedDimensions;
     }
@@ -87,15 +87,15 @@ public class TestSailingFunctionsRegistration {
         Collection<Function<?>> expectedStatistics = new HashSet<>();
         
         Method getDistanceTraveledMethod = HasTrackedLegOfCompetitorContext.class.getMethod("getDistanceTraveled", new Class<?>[0]);
-        expectedStatistics.add(FunctionFactory.createMethodWrappingFunction(getDistanceTraveledMethod));
+        expectedStatistics.add(functionFactory.createMethodWrappingFunction(getDistanceTraveledMethod));
         
         Method getGPSFixMethod = HasGPSFixContext.class.getMethod("getGPSFix", new Class<?>[0]);
-        Function<?> getGPSFix = FunctionFactory.createMethodWrappingFunction(getGPSFixMethod);
+        Function<?> getGPSFix = functionFactory.createMethodWrappingFunction(getGPSFixMethod);
         Method getSpeedMethod = Moving.class.getMethod("getSpeed", new Class<?>[0]);
-        Function<?> getSpeed = FunctionFactory.createMethodWrappingFunction(getSpeedMethod);
+        Function<?> getSpeed = functionFactory.createMethodWrappingFunction(getSpeedMethod);
         Method getKnotsMethod = Speed.class.getMethod("getKnots", new Class<?>[0]);
-        Function<?> getKnots = FunctionFactory.createMethodWrappingFunction(getKnotsMethod);
-        expectedStatistics.add(FunctionFactory.createCompoundFunction(Arrays.asList(getGPSFix, getSpeed, getKnots)));
+        Function<?> getKnots = functionFactory.createMethodWrappingFunction(getKnotsMethod);
+        expectedStatistics.add(functionFactory.createCompoundFunction(Arrays.asList(getGPSFix, getSpeed, getKnots)));
         
         return expectedStatistics;
     }

java/com.sap.sailing.datamining.test/src/com/sap/sailing/datamining/test/util/ConcurrencyTestsUtil.java

@@ -32,7 +32,7 @@ public class ConcurrencyTestsUtil {
         }
     }
 
-    public static void tryToFinishTheProcessorInAnotherThread(final Processor<?> processor) {
+    public static void tryToFinishTheProcessorInAnotherThread(final Processor<?, ?> processor) {
         Runnable finishingRunnable = new Runnable() {
             @Override
             public void run() {

java/com.sap.sailing.datamining.test/src/com/sap/sailing/datamining/test/util/NullProcessor.java

@@ -0,0 +1,37 @@
+package com.sap.sailing.datamining.test.util;
+
+import com.sap.sse.datamining.AdditionalResultDataBuilder;
+import com.sap.sse.datamining.impl.components.AbstractProcessor;
+
+public class NullProcessor<InputType, ResultType> extends AbstractProcessor<InputType, ResultType> {
+
+    public NullProcessor(Class<InputType> inputType, Class<ResultType> resultType) {
+        super(inputType, resultType);
+    }
+
+    @Override
+    public void processElement(InputType element) {
+
+    }
+
+    @Override
+    public void onFailure(Throwable failure) {
+
+    }
+
+    @Override
+    public void finish() throws InterruptedException {
+
+    }
+
+    @Override
+    public void abort() {
+
+    }
+
+    @Override
+    public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
+        return additionalDataBuilder;
+    }
+
+}

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

@@ -1,38 +1,82 @@
 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;
-import org.osgi.framework.ServiceRegistration;
+import org.osgi.framework.ServiceReference;
 
-import com.sap.sailing.datamining.impl.data.SailingDataMiningClassesWithFunctionsService;
-import com.sap.sse.datamining.ClassesWithFunctionsService;
+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.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 ServiceRegistration<ClassesWithFunctionsService> classesWithFunctionsServiceRegistration;
+    private static ServiceReference<ClassesWithFunctionsRegistrationService> classesWithFunctionsRegistrationServiceReference;
+    private static ServiceReference<DataRetrieverChainDefinitionRegistrationService> dataRetrieverChainDefinitionRegistrationServiceServiceReference;
 
     @Override
     public void start(BundleContext context) throws Exception {
         Activator.context = context;
-        registerClassesWithFunctionsService();
+        
+        classesWithFunctionsRegistrationServiceReference = Activator.context.getServiceReference(ClassesWithFunctionsRegistrationService.class);
+        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 {
-        unregisterClassesWithFunctionsService();
+        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);
+            }
+        }
     }
 
-    private void unregisterClassesWithFunctionsService() {
-        context.ungetService(classesWithFunctionsServiceRegistration.getReference());
+    public static Set<Class<?>> getInternalClassesWithMarkedMethods() {
+        Set<Class<?>> internalClasses = new HashSet<>();
+        internalClasses.add(HasTrackedRaceContext.class);
+        internalClasses.add(HasTrackedLegContext.class);
+        internalClasses.add(HasTrackedLegOfCompetitorContext.class);
+        internalClasses.add(HasGPSFixContext.class);
+        return internalClasses;
     }
 
-    private void registerClassesWithFunctionsService() {
-        classesWithFunctionsServiceRegistration = context.registerService(ClassesWithFunctionsService.class,
-                new SailingDataMiningClassesWithFunctionsService(), null);
+    public static Set<Class<?>> getExternalLibraryClasses() {
+        return new HashSet<>();
     }
 
 }

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, "SailingDomainRetrieverChain");
+        @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, "SailingDomainRetrieverChain");
+        @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/HasGPSFixContext.java

@@ -3,7 +3,10 @@ package com.sap.sailing.datamining.data;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sse.datamining.shared.annotations.Connector;
 
-public interface HasGPSFixContext extends HasTrackedLegOfCompetitorContext {
+public interface HasGPSFixContext {
+    
+    @Connector
+    public HasTrackedLegOfCompetitorContext getTrackedLegOfCompetitorContext();
     
     @Connector
     public GPSFixMoving getGPSFix();

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

@@ -2,15 +2,19 @@ package com.sap.sailing.datamining.data;
 
 import com.sap.sailing.domain.common.LegType;
 import com.sap.sailing.domain.tracking.TrackedLeg;
+import com.sap.sse.datamining.shared.annotations.Connector;
 import com.sap.sse.datamining.shared.annotations.Dimension;
 
-public interface HasTrackedLegContext extends HasTrackedRaceContext {
+public interface HasTrackedLegContext {
+    
+    @Connector
+    public HasTrackedRaceContext getTrackedRaceContext();
 
     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/HasTrackedLegOfCompetitorContext.java

@@ -6,7 +6,10 @@ import com.sap.sse.datamining.shared.Unit;
 import com.sap.sse.datamining.shared.annotations.Connector;
 import com.sap.sse.datamining.shared.annotations.Statistic;
 
-public interface HasTrackedLegOfCompetitorContext extends HasTrackedLegContext {
+public interface HasTrackedLegOfCompetitorContext {
+    
+    @Connector
+    public HasTrackedLegContext getTrackedLegContext();
     
     public TrackedLegOfCompetitor getTrackedLegOfCompetitor();
 

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

@@ -1,90 +1,90 @@
 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.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 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.server.RacingEventService;
+import com.sap.sse.datamining.DataRetrieverChainBuilder;
+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.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.ProcessorQuery;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
+import com.sap.sse.datamining.impl.criterias.AndCompoundFilterCriterion;
+import com.sap.sse.datamining.impl.criterias.CompoundFilterCriterion;
+import com.sap.sse.datamining.impl.criterias.NullaryFunctionValuesFilterCriterion;
+import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
-public final class SailingDataMiningFactory {
+public class SailingDataMiningFactory {
+
+    private final ProcessorFactory processorFactory;
     
-    private SailingDataMiningFactory() {
+    private final FunctionProvider functionProvider;
+    private final DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry;
+
+    public SailingDataMiningFactory(FunctionProvider functionProvider, DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry) {
+        processorFactory = new ProcessorFactory(DataMiningActivator.getExecutor());
+        
+        this.functionProvider = functionProvider;
+        this.dataRetrieverChainDefinitionRegistry = dataRetrieverChainDefinitionRegistry;
     }
 
-    public static <ElementType> Query<Double> createQuery(RacingEventService dataSource, final QueryDefinition queryDefinition, final FunctionProvider functionProvider) {
+    public <ElementType> Query<Double> createQuery(RacingEventService dataSource, final QueryDefinition queryDefinition) {
         return new ProcessorQuery<Double, RacingEventService>(DataMiningActivator.getExecutor(), dataSource,
                 DataMiningActivator.getStringMessages(), DataMiningStringMessages.Util.getLocaleFor(queryDefinition.getLocaleInfoName())) {
-            
             @Override
-            protected Processor<RacingEventService> createFirstProcessor() {
-                Processor<GroupedDataEntry<Double>> aggregationProcessor = ProcessorFactory.createAggregationProcessor(/*query*/ this, queryDefinition.getAggregatorType());
-                
+            protected Processor<RacingEventService, ?> createFirstProcessor() {
                 @SuppressWarnings("unchecked") // TODO Clean, after the deprecated components have been removed
                 Function<Double> extractionFunction = (Function<Double>) functionProvider.getFunctionForDTO(queryDefinition.getStatisticToCalculate());
-                Processor<GroupedDataEntry<ElementType>> extractionProcessor = ProcessorFactory.createExtractionProcessor(aggregationProcessor, extractionFunction);
+                @SuppressWarnings("unchecked")
+                Class<ElementType> dataTypeToRetrieve = (Class<ElementType>) extractionFunction.getDeclaringType();
                 
-                List<Function<?>> dimensionsToGroupBy = convertDTOsToFunctions(queryDefinition.getDimensionsToGroupBy(), functionProvider);
-                Processor<ElementType> groupingProcessor = ProcessorFactory.createGroupingProcessor(extractionProcessor, dimensionsToGroupBy);
+                Processor<GroupedDataEntry<Double>, Map<GroupKey, Double>> aggregationProcessor = processorFactory.createAggregationProcessor(/*query*/ this, queryDefinition.getAggregatorType());
+                Processor<GroupedDataEntry<ElementType>, GroupedDataEntry<Double>> extractionProcessor = processorFactory.createExtractionProcessor(aggregationProcessor, extractionFunction);
                 
-                SailingDataRetrievalLevels dataRetrievalLevel = calculateDataRetrievalLevel(extractionFunction);
-                Processor<RacingEventService> firstRetrievalProcessor = SailingDataRetrieverFactory.createRetrievalProcessorChain(dataRetrievalLevel, groupingProcessor, queryDefinition.getFilterSelection(), functionProvider);
-                return firstRetrievalProcessor;
+                List<Function<?>> dimensionsToGroupBy = convertDTOsToFunctions(queryDefinition.getDimensionsToGroupBy());
+                Processor<ElementType, GroupedDataEntry<ElementType>> groupingProcessor = processorFactory.createGroupingProcessor(dataTypeToRetrieve, extractionProcessor, dimensionsToGroupBy);
+
+                DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition = dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinition(RacingEventService.class, queryDefinition.getDataRetrieverChainDefinition().getId());
+                DataRetrieverChainBuilder<RacingEventService> chainBuilder = dataRetrieverChainDefinition.startBuilding(DataMiningActivator.getExecutor());
+                Map<Class<?>, FilterCriterion<?>> criteriaMappedByDataType = createFilterCriteria(queryDefinition.getFilterSelection());
+                do {
+                    if (criteriaMappedByDataType.containsKey(chainBuilder.getCurrentRetrievedDataType())) {
+                        chainBuilder.setFilter(criteriaMappedByDataType.get(chainBuilder.getCurrentRetrievedDataType()));
+                    }
+                    
+                    chainBuilder.stepDeeper();
+                } while (!dataTypeToRetrieve.equals(chainBuilder.getCurrentRetrievedDataType()));
+                if (criteriaMappedByDataType.containsKey(chainBuilder.getCurrentRetrievedDataType())) {
+                    chainBuilder.setFilter(criteriaMappedByDataType.get(chainBuilder.getCurrentRetrievedDataType()));
+                }
+                chainBuilder.addResultReceiver(groupingProcessor);
+                
+                return chainBuilder.build();
             }
             
         };
     }
 
-    @SuppressWarnings("unchecked")
-    public static Query<Set<Object>> createDimensionValuesQuery(RacingEventService dataSource, final Collection<FunctionDTO> dimensionDTOs, final FunctionProvider functionProvider) {
-        return new ProcessorQuery<Set<Object>, RacingEventService>(DataMiningActivator.getExecutor(), dataSource) {
-            @Override
-            protected Processor<RacingEventService> createFirstProcessor() {
-                Processor<GroupedDataEntry<Object>> valueCollector = ProcessorFactory.createGroupedDataCollectingAsSetProcessor(/*query*/ this);
-                
-                Collection<Function<?>> dimensions = convertDTOsToFunctions(dimensionDTOs, functionProvider);
-                Map<SailingDataRetrievalLevels, Collection<Function<?>>> dimensionsMappedByRetrievalLevel = mapFunctionsByRetrievalLevel(dimensions);
-                SailingDataRetrievalLevels deepestRetrievalLevel = getDeepestRetrievalLevel(dimensionsMappedByRetrievalLevel.keySet());
-
-                Processor<?> retrievalProcessor = null;
-                for (int i = deepestRetrievalLevel.ordinal(); i >= 0; i--) {
-                    SailingDataRetrievalLevels retrievalLevel = SailingDataRetrievalLevels.values()[i];
-                    
-                    Collection<Function<?>> dimensionsForRetrievalLevel = dimensionsMappedByRetrievalLevel.containsKey(retrievalLevel) ? dimensionsMappedByRetrievalLevel.get(retrievalLevel) : new ArrayList<Function<?>>();
-                    Collection<Processor<?>> retrievalResultReceivers = ProcessorFactory.createGroupingExtractorsForDimensions(valueCollector, dimensionsForRetrievalLevel);
-                    if (retrievalProcessor != null) {
-                        retrievalResultReceivers.add(retrievalProcessor);
-                    }
-                    
-                    retrievalProcessor = SailingDataRetrieverFactory.createRetrievalProcessorWithoutFilter(retrievalLevel, retrievalResultReceivers);
-                }
-                
-                // A retrieval processor created this way results always in a Processor<RacingEventService>
-                return (Processor<RacingEventService>) retrievalProcessor;
-            }
-        };
-    }
-
-    private static List<Function<?>> convertDTOsToFunctions(Collection<FunctionDTO> functionDTOs, FunctionProvider functionProvider) {
+    private List<Function<?>> convertDTOsToFunctions(Collection<FunctionDTO> functionDTOs) {
         List<Function<?>> dimensionsToGroupBy = new ArrayList<>();
         for (FunctionDTO functionDTO : functionDTOs) {
             dimensionsToGroupBy.add(functionProvider.getFunctionForDTO(functionDTO));
@@ -92,36 +92,70 @@ public final class SailingDataMiningFactory {
         return dimensionsToGroupBy;
     }
     
-    private static Map<SailingDataRetrievalLevels, Collection<Function<?>>> mapFunctionsByRetrievalLevel(Collection<Function<?>> functions) {
-        Map<SailingDataRetrievalLevels, Collection<Function<?>>> mappedFunctions = new HashMap<>();
-        for (Function<?> function : functions) {
-            SailingDataRetrievalLevels retrievalLevel = calculateDataRetrievalLevel(function);
-            if (!mappedFunctions.containsKey(retrievalLevel)) {
-                mappedFunctions.put(retrievalLevel, new HashSet<Function<?>>());
+    @SuppressWarnings("unchecked")
+    private <T> Map<Class<?>, FilterCriterion<?>> createFilterCriteria(Map<FunctionDTO, Iterable<? extends Serializable>> filterSelection) {
+        Map<Class<?>, CompoundFilterCriterion<?>> criteriaMappedByDataType = new HashMap<>();
+        for (Entry<FunctionDTO, Iterable<? extends Serializable>> filterSelectionEntry : filterSelection.entrySet()) {
+            Function<?> function = functionProvider.getFunctionForDTO(filterSelectionEntry.getKey());
+            Class<T> dataType = (Class<T>) function.getDeclaringType();
+            
+            if (!criteriaMappedByDataType.containsKey(dataType)) {
+                criteriaMappedByDataType.put(dataType, new AndCompoundFilterCriterion<>(dataType));
             }
-            mappedFunctions.get(retrievalLevel).add(function);
+
+            Collection<Object> filterValues = new ArrayList<>();
+            for (Object filterValue : filterSelectionEntry.getValue()) {
+                filterValues.add(filterValue);
+            }
+            ((CompoundFilterCriterion<T>) criteriaMappedByDataType.get(dataType)).addCriteria(new NullaryFunctionValuesFilterCriterion<>(dataType, function, filterValues));
+        }
+        return (Map<Class<?>, FilterCriterion<?>>)(Map<Class<?>, ?>) criteriaMappedByDataType;
+    }
+
+    public Query<Set<Object>> createDimensionValuesQuery(RacingEventService dataSource, final DataRetrieverChainDefinitionDTO dataRetrieverChainDefinitionDTO, final String localeInfoName) {
+        final DataMiningStringMessages stringMessages = DataMiningActivator.getStringMessages();
+        final Locale locale = DataMiningStringMessages.Util.getLocaleFor(localeInfoName);
+        return new ProcessorQuery<Set<Object>, RacingEventService>(DataMiningActivator.getExecutor(), dataSource, stringMessages, locale) {
+            @Override
+            protected Processor<RacingEventService, ?> createFirstProcessor() {
+                Processor<GroupedDataEntry<Object>, Map<GroupKey, Set<Object>>> valueCollector = processorFactory.createGroupedDataCollectingAsSetProcessor(/*query*/ this);
+
+                DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition = dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinition(RacingEventService.class, dataRetrieverChainDefinitionDTO.getId());
+                DataRetrieverChainBuilder<RacingEventService> chainBuilder = dataRetrieverChainDefinition.startBuilding(DataMiningActivator.getExecutor());
+                Collection<Function<?>> dimensions = functionProvider.getMinimizedDimensionsFor(dataRetrieverChainDefinition);
+                Map<Class<?>, Collection<Function<?>>> dimensionsMappedByDeclaringType = mapFunctionsByDeclaringType(dimensions);
+                while (!dimensionsMappedByDeclaringType.isEmpty()) {
+                    Class<?> dataType = chainBuilder.getCurrentRetrievedDataType();
+
+                    if (dimensionsMappedByDeclaringType.containsKey(dataType)) {
+                        for (Processor<?, ?> resultReceiver : processorFactory.createGroupingExtractorsForDimensions(
+                                                                dataType, valueCollector, dimensionsMappedByDeclaringType.get(dataType),
+                                                                stringMessages, locale)) {
+                            chainBuilder.addResultReceiver(resultReceiver);
+                        }
+                        dimensionsMappedByDeclaringType.remove(dataType);
+                    }
+                    
+                    if (!dimensionsMappedByDeclaringType.isEmpty()) {
+                        chainBuilder.stepDeeper();
+                    }
+                }
+                
+                return chainBuilder.build();
+            }
+        };
+    }
+
+    private Map<Class<?>, Collection<Function<?>>> mapFunctionsByDeclaringType(Collection<Function<?>> functions) {
+        Map<Class<?>, Collection<Function<?>>> mappedFunctions = new HashMap<>();
+        for (Function<?> function : functions) {
+            Class<?> declaringType = function.getDeclaringType();
+            if (!mappedFunctions.containsKey(declaringType)) {
+                mappedFunctions.put(declaringType, new HashSet<Function<?>>());
+            }
+            mappedFunctions.get(declaringType).add(function);
         }
         return mappedFunctions;
     }
-    
-    private static SailingDataRetrievalLevels calculateDataRetrievalLevel(Function<?> function) {
-        if (function.getDeclaringType().equals(HasTrackedRaceContext.class)) {
-            return SailingDataRetrievalLevels.TrackedRace;
-        }
-        if (function.getDeclaringType().equals(HasTrackedLegContext.class)) {
-            return SailingDataRetrievalLevels.TrackedLeg;
-        }
-        if (function.getDeclaringType().equals(HasTrackedLegOfCompetitorContext.class)) {
-            return SailingDataRetrievalLevels.TrackedLegOfCompetitor;
-        }
-        if (function.getDeclaringType().equals(HasGPSFixContext.class)) {
-            return SailingDataRetrievalLevels.GPSFix;
-        }
-        return SailingDataRetrievalLevels.GPSFix;
-    }
-
-    private static SailingDataRetrievalLevels getDeepestRetrievalLevel(Collection<SailingDataRetrievalLevels> retrievalLevels) {
-        return Collections.max(retrievalLevels);
-    }
 
 }

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

@@ -1,7 +0,0 @@
-package com.sap.sailing.datamining.factories;
-
-public enum SailingDataRetrievalLevels {
-    
-    LeaderboardGroup, RegattaLeaderboard, TrackedRace, TrackedLeg, TrackedLegOfCompetitor, GPSFix
-    
-}

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

@@ -1,141 +0,0 @@
-package com.sap.sailing.datamining.factories;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.ThreadPoolExecutor;
-
-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.components.FilterCriterion;
-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.AndCompoundFilterCriterion;
-import com.sap.sse.datamining.impl.criterias.CompoundFilterCriterion;
-import com.sap.sse.datamining.impl.criterias.NonFilteringFilterCriterion;
-import com.sap.sse.datamining.impl.criterias.NullaryFunctionValuesFilterCriterion;
-import com.sap.sse.datamining.shared.dto.FunctionDTO;
-
-public final class SailingDataRetrieverFactory {
-
-    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 <ElementType> Processor<RacingEventService> createRetrievalProcessorChain(SailingDataRetrievalLevels dataRetrievalLevel, Processor<ElementType> groupingProcessor, Map<FunctionDTO, Iterable<? extends Serializable>> filterSelection, FunctionProvider functionProvider) {
-        Processor<?> resultReceiver = groupingProcessor;
-        for (int i = dataRetrievalLevel.ordinal(); i >= 0; i--) {
-            resultReceiver = createDataRetrieverFor(SailingDataRetrievalLevels.values()[i], resultReceiver, filterSelection, functionProvider);
-        }
-        return (Processor<RacingEventService>) resultReceiver;
-    }
-
-    @SuppressWarnings("unchecked")
-    /* 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<? extends Serializable>> filterSelection, FunctionProvider functionProvider) {
-        ThreadPoolExecutor executor = DataMiningActivator.getExecutor();
-        
-        switch (dataRetrievalLevel) {
-        case GPSFix:
-            Processor<HasGPSFixContext> gpsFixSpecificResultReceiver = (Processor<HasGPSFixContext>) resultReceiver;
-            return new GPSFixRetrievalProcessor(executor, Arrays.asList(gpsFixSpecificResultReceiver));
-        case LeaderboardGroup:
-            Processor<LeaderboardGroup> leaderboardGroupSpecificResultReceiver = (Processor<LeaderboardGroup>) resultReceiver;
-            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, functionProvider));
-        case TrackedLeg:
-            Processor<HasTrackedLegContext> trackedLegSpecificResultReceiver = (Processor<HasTrackedLegContext>) resultReceiver;
-            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, functionProvider));
-        case TrackedRace:
-            Processor<HasTrackedRaceContext> trackedRaceSpecificResultReceiver = (Processor<HasTrackedRaceContext>) resultReceiver;
-            return new TrackedRaceFilteringRetrievalProcessor(executor, Arrays.asList(trackedRaceSpecificResultReceiver), getFilterCriteriaForBaseDataType(HasTrackedRaceContext.class, filterSelection, functionProvider));
-        }
-        throw new IllegalArgumentException("No data retriever implemented for the given data retrieval level '"
-                + dataRetrievalLevel + "'");
-    }
-
-    private static <BaseDataType> FilterCriterion<BaseDataType> getFilterCriteriaForBaseDataType(Class<BaseDataType> baseDataType,
-            Map<FunctionDTO, Iterable<? extends Serializable>> filterSelection, FunctionProvider functionProvider) {
-        CompoundFilterCriterion<BaseDataType> criteria = null;
-        for (Entry<FunctionDTO, Iterable<? extends Serializable>> filterSelectionEntry : filterSelection.entrySet()) {
-            Function<?> function = functionProvider.getFunctionForDTO(filterSelectionEntry.getKey());
-            if (baseDataType.equals(function.getDeclaringType())) {
-                if (criteria == null) {
-                    criteria = new AndCompoundFilterCriterion<>();
-                }
-                
-                Collection<Object> filterValues = new ArrayList<>();
-                for (Object filterValue : filterSelectionEntry.getValue()) {
-                    filterValues.add(filterValue);
-                }
-                criteria.addCriteria(new NullaryFunctionValuesFilterCriterion<BaseDataType>(function, filterValues));
-            }
-        }
-        return criteria != null ? criteria : new NonFilteringFilterCriterion<BaseDataType>();
-    }
-
-    /**
-     * Creates a retrieval processor without filter for the given retrieval level and result receivers.<br>
-     * The input type of the result receivers has to match the result type of the created retrieval processor for the given retrievel level or a {@link ClassCastException} can be thrown.
-     * For example, if the retrieval Level is {@link SailingDataRetrievalLevels#TrackedRace} the input must be {@link HasTrackedRaceContext}.
-     */
-    @SuppressWarnings("unchecked")
-    public static Processor<?> createRetrievalProcessorWithoutFilter(SailingDataRetrievalLevels retrievalLevel,
-            Collection<Processor<?>> retrievalResultReceivers) throws ClassCastException {
-        ThreadPoolExecutor executor = DataMiningActivator.getExecutor();
-        
-        switch (retrievalLevel) {
-        case GPSFix:
-            Collection<Processor<HasGPSFixContext>> gpsFixSpecificResultReceivers = (Collection<Processor<HasGPSFixContext>>)(Collection<?>) retrievalResultReceivers;
-            return new GPSFixRetrievalProcessor(executor, gpsFixSpecificResultReceivers);
-        case LeaderboardGroup:
-            Collection<Processor<LeaderboardGroup>> leaderboardGroupSpecificResultReceivers = (Collection<Processor<LeaderboardGroup>>)(Collection<?>) retrievalResultReceivers;
-            return new LeaderboardGroupRetrievalProcessor(executor, leaderboardGroupSpecificResultReceivers);
-        case RegattaLeaderboard:
-            Collection<Processor<RegattaLeaderboard>> regattaLeaderboardSpecificResultReceivers = (Collection<Processor<RegattaLeaderboard>>)(Collection<?>) retrievalResultReceivers;
-            return new RegattaLeaderboardFilteringRetrievalProcessor(executor, regattaLeaderboardSpecificResultReceivers, new NonFilteringFilterCriterion<RegattaLeaderboard>());
-        case TrackedLeg:
-            Collection<Processor<HasTrackedLegContext>> trackedLegSpecificResultReceivers = (Collection<Processor<HasTrackedLegContext>>)(Collection<?>) retrievalResultReceivers;
-            return new TrackedLegFilteringRetrievalProcessor(executor, trackedLegSpecificResultReceivers, new NonFilteringFilterCriterion<HasTrackedLegContext>());
-        case TrackedLegOfCompetitor:
-            Collection<Processor<HasTrackedLegOfCompetitorContext>> trackedLegOfCompetitorSpecificResultReceivers = (Collection<Processor<HasTrackedLegOfCompetitorContext>>)(Collection<?>) retrievalResultReceivers;
-            return new TrackedLegOfCompetitorFilteringRetrievalProcessor(executor, trackedLegOfCompetitorSpecificResultReceivers, new NonFilteringFilterCriterion<HasTrackedLegOfCompetitorContext>());
-        case TrackedRace:
-            Collection<Processor<HasTrackedRaceContext>> trackedRaceSpecificResultReceivers = (Collection<Processor<HasTrackedRaceContext>>)(Collection<?>) retrievalResultReceivers;
-            return new TrackedRaceFilteringRetrievalProcessor(executor, trackedRaceSpecificResultReceivers, new NonFilteringFilterCriterion<HasTrackedRaceContext>());
-        }
-        throw new IllegalArgumentException("No data retriever implemented for the given data retrieval level '"
-                + retrievalLevel + "'");
-    }
-
-}

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/components/GPSFixRetrievalProcessor.java

@@ -21,14 +21,14 @@ import com.sap.sse.datamining.shared.annotations.DataRetriever;
                level=5)
 public class GPSFixRetrievalProcessor extends AbstractSimpleRetrievalProcessor<HasTrackedLegOfCompetitorContext, HasGPSFixContext> {
 
-    public GPSFixRetrievalProcessor(ExecutorService executor, Collection<Processor<HasGPSFixContext>> resultReceivers) {
-        super(executor, resultReceivers);
+    public GPSFixRetrievalProcessor(ExecutorService executor, Collection<Processor<HasGPSFixContext, ?>> resultReceivers) {
+        super(HasTrackedLegOfCompetitorContext.class, HasGPSFixContext.class, executor, resultReceivers);
     }
 
     @Override
     protected Iterable<HasGPSFixContext> retrieveData(HasTrackedLegOfCompetitorContext element) {
         Collection<HasGPSFixContext> gpsFixesWithContext = new ArrayList<>();
-        GPSFixTrack<Competitor, GPSFixMoving> competitorTrack = element.getTrackedRace().getTrack(element.getCompetitor());
+        GPSFixTrack<Competitor, GPSFixMoving> competitorTrack = element.getTrackedLegContext().getTrackedRaceContext().getTrackedRace().getTrack(element.getCompetitor());
         competitorTrack.lockForRead();
         try {
             TrackedLegOfCompetitor trackedLegOfCompetitor = element.getTrackedLegOfCompetitor();

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/components/LeaderboardGroupRetrievalProcessor.java

@@ -17,8 +17,8 @@ public class LeaderboardGroupRetrievalProcessor extends
         AbstractSimpleRetrievalProcessor<RacingEventService, LeaderboardGroup> {
 
     public LeaderboardGroupRetrievalProcessor(ExecutorService executor,
-            Collection<Processor<LeaderboardGroup>> resultReceivers) {
-        super(executor, resultReceivers);
+            Collection<Processor<LeaderboardGroup, ?>> resultReceivers) {
+        super(RacingEventService.class, LeaderboardGroup.class, executor, resultReceivers);
     }
 
     @Override

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/components/RegattaLeaderboardFilteringRetrievalProcessor.java

@@ -8,20 +8,19 @@ import com.sap.sailing.datamining.Activator;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.LeaderboardGroup;
 import com.sap.sailing.domain.leaderboard.RegattaLeaderboard;
-import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.impl.components.AbstractSimpleFilteringRetrievalProcessor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
 import com.sap.sse.datamining.shared.annotations.DataRetriever;
 
 @DataRetriever(dataType=RegattaLeaderboard.class,
                groupName=Activator.dataRetrieverGroupName,
                level=1)
 public class RegattaLeaderboardFilteringRetrievalProcessor extends
-        AbstractSimpleFilteringRetrievalProcessor<LeaderboardGroup, RegattaLeaderboard> {
+        AbstractSimpleRetrievalProcessor<LeaderboardGroup, RegattaLeaderboard> {
 
     public RegattaLeaderboardFilteringRetrievalProcessor(ExecutorService executor,
-            Collection<Processor<RegattaLeaderboard>> resultReceivers, FilterCriterion<RegattaLeaderboard> criteria) {
-        super(executor, resultReceivers, criteria);
+            Collection<Processor<RegattaLeaderboard, ?>> resultReceivers) {
+        super(LeaderboardGroup.class, RegattaLeaderboard.class, executor, resultReceivers);
     }
 
     @Override

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/components/TrackedLegFilteringRetrievalProcessor.java

@@ -9,20 +9,19 @@ import com.sap.sailing.datamining.data.HasTrackedLegContext;
 import com.sap.sailing.datamining.data.HasTrackedRaceContext;
 import com.sap.sailing.datamining.impl.data.TrackedLegWithContext;
 import com.sap.sailing.domain.tracking.TrackedLeg;
-import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.impl.components.AbstractSimpleFilteringRetrievalProcessor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
 import com.sap.sse.datamining.shared.annotations.DataRetriever;
 
 @DataRetriever(dataType=HasTrackedLegContext.class,
                groupName=Activator.dataRetrieverGroupName,
                level=3)
 public class TrackedLegFilteringRetrievalProcessor extends
-        AbstractSimpleFilteringRetrievalProcessor<HasTrackedRaceContext, HasTrackedLegContext> {
+        AbstractSimpleRetrievalProcessor<HasTrackedRaceContext, HasTrackedLegContext> {
 
     public TrackedLegFilteringRetrievalProcessor(ExecutorService executor,
-            Collection<Processor<HasTrackedLegContext>> resultReceivers, FilterCriterion<HasTrackedLegContext> criteria) {
-        super(executor, resultReceivers, criteria);
+            Collection<Processor<HasTrackedLegContext, ?>> resultReceivers) {
+        super(HasTrackedRaceContext.class, HasTrackedLegContext.class, executor, resultReceivers);
     }
 
     @Override

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/components/TrackedLegOfCompetitorFilteringRetrievalProcessor.java

@@ -9,27 +9,25 @@ import com.sap.sailing.datamining.data.HasTrackedLegContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
 import com.sap.sailing.datamining.impl.data.TrackedLegOfCompetitorWithContext;
 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.impl.components.AbstractSimpleFilteringRetrievalProcessor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
 import com.sap.sse.datamining.shared.annotations.DataRetriever;
 
 @DataRetriever(dataType=HasTrackedLegOfCompetitorContext.class,
                groupName=Activator.dataRetrieverGroupName,
                level=4)
 public class TrackedLegOfCompetitorFilteringRetrievalProcessor extends
-        AbstractSimpleFilteringRetrievalProcessor<HasTrackedLegContext, HasTrackedLegOfCompetitorContext> {
+        AbstractSimpleRetrievalProcessor<HasTrackedLegContext, HasTrackedLegOfCompetitorContext> {
 
     public TrackedLegOfCompetitorFilteringRetrievalProcessor(ExecutorService executor,
-            Collection<Processor<HasTrackedLegOfCompetitorContext>> resultReceivers,
-            FilterCriterion<HasTrackedLegOfCompetitorContext> criteria) {
-        super(executor, resultReceivers, criteria);
+            Collection<Processor<HasTrackedLegOfCompetitorContext, ?>> resultReceivers) {
+        super(HasTrackedLegContext.class, HasTrackedLegOfCompetitorContext.class, executor, resultReceivers);
     }
 
     @Override
     protected Iterable<HasTrackedLegOfCompetitorContext> retrieveData(HasTrackedLegContext element) {
         Collection<HasTrackedLegOfCompetitorContext> trackedLegOfCompetitorsWithContext = new ArrayList<>();
-        for (Competitor competitor : element.getRace().getCompetitors()) {
+        for (Competitor competitor : element.getTrackedRaceContext().getTrackedRace().getRace().getCompetitors()) {
             HasTrackedLegOfCompetitorContext trackedLegOfCompetitorWithContext = new TrackedLegOfCompetitorWithContext(element, element.getTrackedLeg().getTrackedLeg(competitor));
             trackedLegOfCompetitorsWithContext.add(trackedLegOfCompetitorWithContext);
         }

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/components/TrackedRaceFilteringRetrievalProcessor.java

@@ -11,20 +11,19 @@ import com.sap.sailing.domain.base.RaceColumn;
 import com.sap.sailing.domain.base.Regatta;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.tracking.TrackedRace;
-import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.impl.components.AbstractSimpleFilteringRetrievalProcessor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
 import com.sap.sse.datamining.shared.annotations.DataRetriever;
 
 @DataRetriever(dataType=HasTrackedRaceContext.class,
                groupName="Sailing",
                level=2)
 public class TrackedRaceFilteringRetrievalProcessor extends
-        AbstractSimpleFilteringRetrievalProcessor<Leaderboard, HasTrackedRaceContext> {
+        AbstractSimpleRetrievalProcessor<Leaderboard, HasTrackedRaceContext> {
 
     public TrackedRaceFilteringRetrievalProcessor(ExecutorService executor,
-            Collection<Processor<HasTrackedRaceContext>> resultReceivers, FilterCriterion<HasTrackedRaceContext> criteria) {
-        super(executor, resultReceivers, criteria);
+            Collection<Processor<HasTrackedRaceContext, ?>> resultReceivers) {
+        super(Leaderboard.class, HasTrackedRaceContext.class, executor, resultReceivers);
     }
 
     @Override

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/data/GPSFixWithContext.java

@@ -2,27 +2,23 @@ package com.sap.sailing.datamining.impl.data;
 
 import com.sap.sailing.datamining.data.HasGPSFixContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
-import com.sap.sailing.domain.base.Fleet;
-import com.sap.sailing.domain.base.Regatta;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
-import com.sap.sailing.domain.tracking.TrackedLeg;
-import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-import com.sap.sailing.domain.tracking.TrackedRace;
 
-public class GPSFixWithContext extends TrackedLegOfCompetitorWithContext implements HasGPSFixContext {
+public class GPSFixWithContext implements HasGPSFixContext {
+    
+    private final HasTrackedLegOfCompetitorContext trackedLegOfCompetitorContext;
     
     private final GPSFixMoving gpsFix;
 
-    public GPSFixWithContext(HasTrackedLegOfCompetitorContext legContext, GPSFixMoving gpsFix) {
-        this(legContext.getRegatta(), legContext.getFleet(), legContext.getTrackedRace(),
-                legContext.getTrackedLeg(), legContext.getLegNumber(), legContext.getTrackedLegOfCompetitor(), gpsFix);
-    }
-
-    public GPSFixWithContext(Regatta regatta, Fleet fleet, TrackedRace trackedRace,
-            TrackedLeg trackedLeg, int legNumber, TrackedLegOfCompetitor trackedLegOfCompetitor, GPSFixMoving gpsFix) {
-        super(regatta, fleet, trackedRace, trackedLeg, legNumber, trackedLegOfCompetitor);
+    public GPSFixWithContext(HasTrackedLegOfCompetitorContext trackedLegOfCompetitorContext, GPSFixMoving gpsFix) {
+        this.trackedLegOfCompetitorContext = trackedLegOfCompetitorContext;
         this.gpsFix = gpsFix;
     }
+    
+    @Override
+    public HasTrackedLegOfCompetitorContext getTrackedLegOfCompetitorContext() {
+        return trackedLegOfCompetitorContext;
+    }
 
     @Override
     public GPSFixMoving getGPSFix() {

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/data/SailingDataMiningClassesWithFunctionsService.java

@@ -1,30 +0,0 @@
-package com.sap.sailing.datamining.impl.data;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import com.sap.sailing.datamining.data.HasGPSFixContext;
-import com.sap.sse.datamining.ClassesWithFunctionsService;
-
-public class SailingDataMiningClassesWithFunctionsService implements ClassesWithFunctionsService {
-
-    @Override
-    public Set<Class<?>> getInternalClassesWithMarkedMethods() {
-        Set<Class<?>> internalClasses = new HashSet<>();
-        /*
-         * This also contains the marked methods of
-         * HasTrackedRaceContext,
-         * HasTrackedLegContext and
-         * HasTrackedLegOfCompetitorContext,
-         * because these are the super types of HasGPSFixContext.
-         */
-        internalClasses.add(HasGPSFixContext.class);
-        return internalClasses;
-    }
-
-    @Override
-    public Set<Class<?>> getExternalLibraryClasses() {
-        return new HashSet<>();
-    }
-
-}

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/data/TrackedLegOfCompetitorWithContext.java

@@ -3,31 +3,27 @@ package com.sap.sailing.datamining.impl.data;
 import com.sap.sailing.datamining.data.HasTrackedLegContext;
 import com.sap.sailing.datamining.data.HasTrackedLegOfCompetitorContext;
 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.Fleet;
-import com.sap.sailing.domain.base.Regatta;
 import com.sap.sailing.domain.common.TimePoint;
-import com.sap.sailing.domain.tracking.TrackedLeg;
 import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-import com.sap.sailing.domain.tracking.TrackedRace;
 
-public class TrackedLegOfCompetitorWithContext extends TrackedLegWithContext implements HasTrackedLegOfCompetitorContext {
+public class TrackedLegOfCompetitorWithContext implements HasTrackedLegOfCompetitorContext {
 
+    private final HasTrackedLegContext trackedLegContext;
+    
     private final TrackedLegOfCompetitor trackedLegOfCompetitor;
     private final Competitor competitor;
 
     public TrackedLegOfCompetitorWithContext(HasTrackedLegContext trackedLegContext, TrackedLegOfCompetitor trackedLegOfCompetitor) {
-        this(trackedLegContext.getRegatta(), trackedLegContext.getFleet(),
-                trackedLegContext.getTrackedRace(), trackedLegContext.getTrackedLeg(),
-                trackedLegContext.getLegNumber(), trackedLegOfCompetitor);
-    }
-
-    public TrackedLegOfCompetitorWithContext(Regatta regatta, Fleet fleet, TrackedRace trackedRace,
-            TrackedLeg trackedLeg, int legNumber, TrackedLegOfCompetitor trackedLegOfCompetitor) {
-        super(regatta, fleet, trackedRace, trackedLeg, legNumber);
+        this.trackedLegContext = trackedLegContext;
         this.trackedLegOfCompetitor = trackedLegOfCompetitor;
         this.competitor = trackedLegOfCompetitor.getCompetitor();
     }
     
+    @Override
+    public HasTrackedLegContext getTrackedLegContext() {
+        return trackedLegContext;
+    }
+
     @Override
     public TrackedLegOfCompetitor getTrackedLegOfCompetitor() {
         return trackedLegOfCompetitor;
@@ -40,7 +36,7 @@ public class TrackedLegOfCompetitorWithContext extends TrackedLegWithContext imp
     
     @Override
     public Double getDistanceTraveled() {
-        TimePoint timePoint = getTrackedRace().getEndOfTracking();
+        TimePoint timePoint = getTrackedLegContext().getTrackedRaceContext().getTrackedRace().getEndOfTracking();
         return getTrackedLegOfCompetitor().getDistanceTraveled(timePoint).getMeters();
     }
 

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/data/TrackedLegWithContext.java

@@ -2,17 +2,16 @@ package com.sap.sailing.datamining.impl.data;
 
 import com.sap.sailing.datamining.data.HasTrackedLegContext;
 import com.sap.sailing.datamining.data.HasTrackedRaceContext;
-import com.sap.sailing.domain.base.Fleet;
-import com.sap.sailing.domain.base.Regatta;
 import com.sap.sailing.domain.common.LegType;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.tracking.TrackedLeg;
 import com.sap.sailing.domain.tracking.TrackedLegOfCompetitor;
-import com.sap.sailing.domain.tracking.TrackedRace;
 
-public class TrackedLegWithContext extends TrackedRaceWithContext implements HasTrackedLegContext {
+public class TrackedLegWithContext implements HasTrackedLegContext {
+
+    private final HasTrackedRaceContext trackedRaceContext;
     
     private final TrackedLeg trackedLeg;
     private final int legNumber;
@@ -20,15 +19,15 @@ public class TrackedLegWithContext extends TrackedRaceWithContext implements Has
     private boolean legTypeHasBeenInitialized;
 
     public TrackedLegWithContext(HasTrackedRaceContext trackedRaceContext, TrackedLeg trackedLeg, int legNumber) {
-        this(trackedRaceContext.getRegatta(), trackedRaceContext.getFleet(),
-                trackedRaceContext.getTrackedRace(), trackedLeg, legNumber);
-    }
-    
-    public TrackedLegWithContext(Regatta regatta, Fleet fleet, TrackedRace trackedRace, TrackedLeg trackedLeg, int legNumber) {
-        super(regatta, fleet, trackedRace);
+        this.trackedRaceContext = trackedRaceContext;
         this.trackedLeg = trackedLeg;
         this.legNumber = legNumber;
     }
+
+    @Override
+    public HasTrackedRaceContext getTrackedRaceContext() {
+        return trackedRaceContext;
+    }
     
     @Override
     public TrackedLeg getTrackedLeg() {

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/client/StringMessages.java

@@ -1094,6 +1094,8 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages {
     String raceVisibilityColumn();
     String enterCarryValueFor(String competitorName);
     String advanced();
+    String basedOn();
+    String retrieveWith();
     String mappingDetails();
     String deviceMappingQrCodeExplanation();
     String qrCode();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties

@@ -1076,6 +1076,8 @@ showAll=Show all
 raceVisibilityColumn=Visibility
 enterCarryValueFor=Enter carried points for competitor {0}
 advanced=Advanced
+basedOn=based on
+retrieveWith=Retrieve with
 mappingDetails=Mapping Details
 deviceMappingQrCodeExplanation=If you are using the Tracking App, you can add the device mapping also by selecting a competitor/mark, setting the from and to times, and then scanning this QRCode.
 qrCode=QRCode
@@ -1084,4 +1086,4 @@ enterCourseName=Enter course name...
 enterImageURL=Enter image URL...
 enterVideoURL=Enter video URL...
 enterSponsorImageURL=Enter sponsor image URL...
-enterRaceName=Enter race name...
+enterRaceName=Enter race name...

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties

@@ -1071,6 +1071,7 @@ showAll=Alle zeigen
 raceVisibilityColumn=Sichtbarkeit
 enterCarryValueFor=Punkteübertrag für Teilnehmer {0} erfassen
 advanced=Erweitert
+retrieveWith=Beschaffe mit
 mappingDetails=Zuordnungsdetails
 deviceMappingQrCodeExplanation=Wenn die Tracking App verwendet wird, kann die Zuordnung auch wie folgt geschehen: Wettbewerber/Tonne auswaehlen, von und bis Zeiten setzen und dann den QRCode abscannen.
 qrCode=QRCode
@@ -1079,4 +1080,4 @@ enterCourseName=Regattakurs-Namen eingeben...
 enterImageURL=Bild-URL eingeben...
 enterVideoURL=Video-URL eingeben...
 enterSponsorImageURL=Sponsorbild-URL eingeben...
-enterRaceName=Wettfahrtnamen eingeben...
+enterRaceName=Wettfahrtnamen eingeben...

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/DataMiningService.java

@@ -9,6 +9,7 @@ import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.QueryResult;
 import com.sap.sse.datamining.shared.SSEDataMiningSerializationDummy;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public interface DataMiningService extends RemoteService {
 
@@ -16,7 +17,9 @@ public interface DataMiningService extends RemoteService {
     
     Collection<FunctionDTO> getDimensionsFor(FunctionDTO statisticToCalculate, String localeInfoName);
 
-    QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception;
+    Collection<DataRetrieverChainDefinitionDTO> getDataRetrieverChainDefinitionsFor(FunctionDTO statisticToCalculate, String localeInfoName);
+
+    QueryResult<Set<Object>> getDimensionValuesFor(DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition, String localeInfoName) throws Exception;
     
     <ResultType extends Number> QueryResult<ResultType> runQuery(QueryDefinition queryDefinition) throws Exception;
 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/DataMiningServiceAsync.java

@@ -10,6 +10,7 @@ import com.sap.sse.datamining.shared.QueryResult;
 import com.sap.sse.datamining.shared.SSEDataMiningSerializationDummy;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public interface DataMiningServiceAsync {
 
@@ -17,7 +18,10 @@ public interface DataMiningServiceAsync {
 
     void getDimensionsFor(FunctionDTO statisticToCalculate, String localeInfoName, AsyncCallback<Collection<FunctionDTO>> callback);
     
-    void getDimensionValuesFor(Collection<FunctionDTO> dimensions, AsyncCallback<QueryResult<Set<Object>>> callback);
+    void getDataRetrieverChainDefinitionsFor(FunctionDTO statisticToCalculate, String localeInfoName,
+            AsyncCallback<Collection<DataRetrieverChainDefinitionDTO>> callback);
+    
+    void getDimensionValuesFor(DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition, String localeInfoName, AsyncCallback<QueryResult<Set<Object>>> callback);
 
     <ResultType extends Number> void runQuery(QueryDefinition queryDefinition, AsyncCallback<QueryResult<ResultType>> callback);
     

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/DataRetrieverChainDefinitionChangedListener.java

@@ -0,0 +1,9 @@
+package com.sap.sailing.gwt.ui.datamining;
+
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
+
+public interface DataRetrieverChainDefinitionChangedListener {
+    
+    public void dataRetrieverChainDefinitionChanged(DataRetrieverChainDefinitionDTO newDataRetrieverChainDefinition);
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/DataRetrieverChainDefinitionProvider.java

@@ -0,0 +1,15 @@
+package com.sap.sailing.gwt.ui.datamining;
+
+import com.sap.sailing.gwt.ui.client.shared.components.Component;
+import com.sap.sse.datamining.shared.QueryDefinition;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
+
+public interface DataRetrieverChainDefinitionProvider extends Component<Object> {
+    
+    public DataRetrieverChainDefinitionDTO getDataRetrieverChainDefinition();
+
+    public void addDataRetrieverChainDefinitionChangedListener(DataRetrieverChainDefinitionChangedListener listener);
+    
+    public void applyQueryDefinition(QueryDefinition queryDefinition);
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/GroupingProvider.java

@@ -4,13 +4,10 @@ import java.util.Collection;
 
 import com.sap.sailing.gwt.ui.client.shared.components.Component;
 import com.sap.sse.datamining.shared.QueryDefinition;
-import com.sap.sse.datamining.shared.components.GrouperType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
 public interface GroupingProvider extends Component<Object> {
     
-    public GrouperType getGrouperType();
-    
     public Collection<FunctionDTO> getDimensionsToGroupBy();
     public String getCustomGrouperScriptText();
     

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/ExtractionFunctionSet.java

@@ -0,0 +1,69 @@
+package com.sap.sailing.gwt.ui.datamining.selection;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+import com.sap.sse.common.Util.Pair;
+import com.sap.sse.datamining.shared.dto.FunctionDTO;
+
+public class ExtractionFunctionSet {
+    
+    private final Map<FunctionDTOKey, FunctionDTO> functionDTOMap;
+    private final Map<StrippedFunctionDTO, Collection<String>> sourceTypeNamesMap;
+    
+    public ExtractionFunctionSet() {
+        functionDTOMap = new HashMap<>();
+        sourceTypeNamesMap = new HashMap<>();
+    }
+
+    public void addAll(Collection<FunctionDTO> functionDTOs) {
+        for (FunctionDTO functionDTO : functionDTOs) {
+            add(functionDTO);
+        }
+    }
+    
+    private void add(FunctionDTO functionDTO) {
+        String sourceTypeName = functionDTO.getSourceTypeName();
+        StrippedFunctionDTO strippedFunctionDTO = new StrippedFunctionDTO(functionDTO);
+        FunctionDTOKey key = new FunctionDTOKey(strippedFunctionDTO, sourceTypeName);
+        
+        if (!functionDTOMap.containsKey(key)) {
+            functionDTOMap.put(key, functionDTO);
+            
+            if (!sourceTypeNamesMap.containsKey(strippedFunctionDTO)) {
+                sourceTypeNamesMap.put(strippedFunctionDTO, new HashSet<String>());
+            }
+            sourceTypeNamesMap.get(strippedFunctionDTO).add(sourceTypeName);
+        }
+    }
+
+    public Collection<StrippedFunctionDTO> getStrippedFunctionDTOs() {
+        return sourceTypeNamesMap.keySet();
+    }
+    
+    public Collection<String> getSourceTypeNames(StrippedFunctionDTO strippedFunctionDTO) {
+        return sourceTypeNamesMap.get(strippedFunctionDTO);
+    }
+    
+    public FunctionDTO getFunctionDTO(StrippedFunctionDTO strippedFunctionDTO, String sourceTypeName) {
+        FunctionDTOKey key = new FunctionDTOKey(strippedFunctionDTO, sourceTypeName);
+        return functionDTOMap.get(key);
+    }
+    
+    public void clear() {
+        functionDTOMap.clear();
+        sourceTypeNamesMap.clear();
+    }
+    
+    private class FunctionDTOKey extends Pair<StrippedFunctionDTO, String> {
+        private static final long serialVersionUID = -5703889518055076338L;
+
+        public FunctionDTOKey(StrippedFunctionDTO a, String b) {
+            super(a, b);
+        }
+        
+    }
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/MultiDimensionalGroupingProvider.java

@@ -27,7 +27,6 @@ import com.sap.sailing.gwt.ui.datamining.StatisticChangedListener;
 import com.sap.sailing.gwt.ui.datamining.StatisticProvider;
 import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.components.AggregatorType;
-import com.sap.sse.datamining.shared.components.GrouperType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 
 public class MultiDimensionalGroupingProvider implements GroupingProvider, StatisticChangedListener {
@@ -158,11 +157,6 @@ public class MultiDimensionalGroupingProvider implements GroupingProvider, Stati
         }
     }
 
-    @Override
-    public GrouperType getGrouperType() {
-        return GrouperType.Dimensions;
-    }
-
     @Override
     public Collection<FunctionDTO> getDimensionsToGroupBy() {
         Collection<FunctionDTO> dimensionsToGroupBy = new ArrayList<FunctionDTO>();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/QueryDefinitionProviderWithControls.java

@@ -11,6 +11,7 @@ import com.google.gwt.user.client.ui.Button;
 import com.google.gwt.user.client.ui.FlowPanel;
 import com.google.gwt.user.client.ui.HorizontalPanel;
 import com.google.gwt.user.client.ui.RequiresResize;
+import com.google.gwt.user.client.ui.VerticalPanel;
 import com.google.gwt.user.client.ui.Widget;
 import com.sap.sailing.gwt.ui.client.ErrorReporter;
 import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
@@ -19,6 +20,7 @@ import com.sap.sailing.gwt.ui.client.shared.components.SettingsDialogComponent;
 import com.sap.sailing.gwt.ui.client.shared.panels.ResizingFlowPanel;
 import com.sap.sailing.gwt.ui.datamining.DataMiningControls;
 import com.sap.sailing.gwt.ui.datamining.DataMiningServiceAsync;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionChangedListener;
 import com.sap.sailing.gwt.ui.datamining.GroupingChangedListener;
 import com.sap.sailing.gwt.ui.datamining.SelectionChangedListener;
 import com.sap.sailing.gwt.ui.datamining.SelectionProvider;
@@ -28,17 +30,19 @@ import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.shared.impl.QueryDefinitionImpl;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public class QueryDefinitionProviderWithControls extends AbstractQueryDefinitionProvider implements DataMiningControls {
 
     private FlowPanel mainPanel;
     private HorizontalPanel controlsPanel;
-
-    private SelectionProvider<?> selectionProvider;
     
     private StatisticProvider statisticProvider;
+    private SimpleDataRetrieverChainDefinitionProvider retrieverChainProvider;
 
     private MultiDimensionalGroupingProvider groupBySelectionPanel;
+    
+    private SelectionProvider<?> selectionProvider;
 
     public QueryDefinitionProviderWithControls(StringMessages stringMessages, SailingServiceAsync sailingService, DataMiningServiceAsync dataMiningService, ErrorReporter errorReporter) {
         super(stringMessages, sailingService, dataMiningService, errorReporter);
@@ -55,7 +59,7 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
 
         mainPanel.add(createFunctionsPanel());
 
-        selectionProvider = new RefreshingSelectionTablesPanel(stringMessages, dataMiningService, errorReporter, statisticProvider);
+        selectionProvider = new RefreshingSelectionTablesPanel(stringMessages, dataMiningService, errorReporter, retrieverChainProvider);
         selectionProvider.addSelectionChangedListener(new SelectionChangedListener() {
             @Override
             public void selectionChanged() {
@@ -70,6 +74,7 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
         HorizontalPanel functionsPanel = new HorizontalPanel();
         functionsPanel.setSpacing(5);
 
+        VerticalPanel statisticAndRetrieverChainPanel = new VerticalPanel();
         statisticProvider = new SimpleStatisticProvider(getStringMessages(), getDataMiningService(), getErrorReporter());
         statisticProvider.addStatisticChangedListener(new StatisticChangedListener() {
             @Override
@@ -77,7 +82,17 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
                 notifyQueryDefinitionChanged();
             }
         });
-        functionsPanel.add(statisticProvider.getEntryWidget());
+        statisticAndRetrieverChainPanel.add(statisticProvider.getEntryWidget());
+        
+        retrieverChainProvider = new SimpleDataRetrieverChainDefinitionProvider(getStringMessages(), getDataMiningService(), getErrorReporter(), statisticProvider);
+        retrieverChainProvider.addDataRetrieverChainDefinitionChangedListener(new DataRetrieverChainDefinitionChangedListener() {
+            @Override
+            public void dataRetrieverChainDefinitionChanged(DataRetrieverChainDefinitionDTO newDataRetrieverChainDefinition) {
+                notifyQueryDefinitionChanged();
+            }
+        });
+        statisticAndRetrieverChainPanel.add(retrieverChainProvider.getEntryWidget());
+        functionsPanel.add(statisticAndRetrieverChainPanel);
 
         groupBySelectionPanel = new MultiDimensionalGroupingProvider(getStringMessages(), getDataMiningService(), getErrorReporter(), statisticProvider);
         groupBySelectionPanel.addGroupingChangedListener(new GroupingChangedListener() {
@@ -107,7 +122,7 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
     @Override
     public QueryDefinition getQueryDefinition() {
         QueryDefinitionImpl queryDTO = new QueryDefinitionImpl(LocaleInfo.getCurrentLocale().getLocaleName(), statisticProvider.getStatisticToCalculate(),
-                                                               statisticProvider.getAggregatorType());
+                                                               statisticProvider.getAggregatorType(), retrieverChainProvider.getDataRetrieverChainDefinition());
         
         for (FunctionDTO dimension : groupBySelectionPanel.getDimensionsToGroupBy()) {
             queryDTO.appendDimensionToGroupBy(dimension);
@@ -123,9 +138,10 @@ public class QueryDefinitionProviderWithControls extends AbstractQueryDefinition
     @Override
     public void applyQueryDefinition(QueryDefinition queryDefinition) {
         setBlockChangeNotification(true);
-        selectionProvider.applySelection(queryDefinition);
-        groupBySelectionPanel.applyQueryDefinition(queryDefinition);
         statisticProvider.applyQueryDefinition(queryDefinition);
+        retrieverChainProvider.applyQueryDefinition(queryDefinition);
+        groupBySelectionPanel.applyQueryDefinition(queryDefinition);
+        selectionProvider.applySelection(queryDefinition);
         setBlockChangeNotification(false);
         
         notifyQueryDefinitionChanged();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/RefreshingSelectionTablesPanel.java

@@ -26,20 +26,21 @@ import com.sap.sailing.gwt.ui.client.ErrorReporter;
 import com.sap.sailing.gwt.ui.client.StringMessages;
 import com.sap.sailing.gwt.ui.client.shared.components.SettingsDialogComponent;
 import com.sap.sailing.gwt.ui.datamining.DataMiningServiceAsync;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionChangedListener;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionProvider;
 import com.sap.sailing.gwt.ui.datamining.SelectionChangedListener;
 import com.sap.sailing.gwt.ui.datamining.SelectionProvider;
-import com.sap.sailing.gwt.ui.datamining.StatisticChangedListener;
-import com.sap.sailing.gwt.ui.datamining.StatisticProvider;
 import com.sap.sailing.gwt.ui.datamining.settings.RefreshingSelectionTablesSettings;
 import com.sap.sailing.gwt.ui.datamining.settings.RefreshingSelectionTablesSettingsDialogComponent;
+import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.QueryResult;
-import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public class RefreshingSelectionTablesPanel implements SelectionProvider<RefreshingSelectionTablesSettings>,
-                                                       StatisticChangedListener {
+                                                       DataRetrieverChainDefinitionChangedListener {
     
     private static final int resizeDelay = 100;
     private static final double relativeWidthInPercent = 1;
@@ -57,18 +58,18 @@ public class RefreshingSelectionTablesPanel implements SelectionProvider<Refresh
     private Map<GenericGroupKey<FunctionDTO>, SelectionTable<?>> tablesMappedByDimensionAsKeys;
     private Set<SelectionChangedListener> listeners;
     
-    private FunctionDTO currentStatisticToCalculate;
+    private DataRetrieverChainDefinitionDTO currentDataRetrieverChainDefinition;
     
     public RefreshingSelectionTablesPanel(StringMessages stringMessages, DataMiningServiceAsync dataMiningService, ErrorReporter errorReporter,
-                                          StatisticProvider statisticProvider) {
+                                          DataRetrieverChainDefinitionProvider dataRetrieverChainDefinitionProvider) {
         this.stringMessages = stringMessages;
         this.dataMiningService = dataMiningService;
         this.errorReporter = errorReporter;
         settings = new RefreshingSelectionTablesSettings();
         listeners = new HashSet<SelectionChangedListener>();
-        currentStatisticToCalculate = null;
+        currentDataRetrieverChainDefinition = null;
 
-        tablesMappedByDimensionAsKeys = new HashMap<GenericGroupKey<FunctionDTO>, SelectionTable<?>>();
+        tablesMappedByDimensionAsKeys = new HashMap<>();
         
         tablesPanel = new HorizontalPanel();
         
@@ -93,68 +94,79 @@ public class RefreshingSelectionTablesPanel implements SelectionProvider<Refresh
         });
 
         doLayout(Window.getClientWidth(), Window.getClientHeight());
-        statisticProvider.addStatisticChangedListener(this);
+        dataRetrieverChainDefinitionProvider.addDataRetrieverChainDefinitionChangedListener(this);
     }
     
     @Override
-    public void statisticChanged(FunctionDTO newStatisticToCalculate, AggregatorType newAggregatorType) {
-        if (!Objects.equals(currentStatisticToCalculate, newStatisticToCalculate)) {
-            currentStatisticToCalculate = newStatisticToCalculate;
-            updateAvailableTables();
+    public void dataRetrieverChainDefinitionChanged(DataRetrieverChainDefinitionDTO newDataRetrieverChainDefinition) {
+        if (!Objects.equals(currentDataRetrieverChainDefinition, newDataRetrieverChainDefinition)) {
+            currentDataRetrieverChainDefinition = newDataRetrieverChainDefinition;
+            timer.cancel();
+            updateTables();
         }
     }
     
-    private void updateAvailableTables() {
-        dataMiningService.getDimensionsFor(currentStatisticToCalculate, LocaleInfo.getCurrentLocale().getLocaleName(), new AsyncCallback<Collection<FunctionDTO>>() {
+    private void updateTables() {
+        dataMiningService.getDimensionValuesFor(currentDataRetrieverChainDefinition, LocaleInfo.getCurrentLocale().getLocaleName(), new AsyncCallback<QueryResult<Set<Object>>>() {
             @Override
             public void onFailure(Throwable caught) {
                 errorReporter.reportError("Error fetching the dimensions from the server: " + caught.getMessage());
             }
             @Override
-            public void onSuccess(Collection<FunctionDTO> dimensions) {
-                Collection<GenericGroupKey<FunctionDTO>> dimensionsAsKeys = new HashSet<>();
-                for (FunctionDTO dimension : dimensions) {
-                    dimensionsAsKeys.add(new GenericGroupKey<FunctionDTO>(dimension));
-                }
+            public void onSuccess(QueryResult<Set<Object>> dimensionValues) {
+                @SuppressWarnings("unchecked")
+                Collection<GenericGroupKey<FunctionDTO>> dimensionsAsKeys = (Collection<GenericGroupKey<FunctionDTO>>)(Collection<?>) dimensionValues.getResults().keySet();
+                updateAvailableTables(dimensionsAsKeys);
                 
-                Collection<GenericGroupKey<FunctionDTO>> dimensionTablesToBeRemoved = new HashSet<>(tablesMappedByDimensionAsKeys.keySet());
-                dimensionTablesToBeRemoved.removeAll(dimensionsAsKeys);
-                for (GenericGroupKey<FunctionDTO> dimensionToBeRemoved : dimensionTablesToBeRemoved) {
-                    tablesMappedByDimensionAsKeys.remove(dimensionToBeRemoved);
+                boolean tableContentChanged = updateTableValues(dimensionValues.getResults());
+                if (settings.isRerunQueryAfterRefresh() && tableContentChanged) {
+                    notifySelectionChanged();
+                    // TODO query is executed, before the data is ready to be analyzed
+                    // TODO does this error still appear with the new concept?
                 }
-                
-                for (GenericGroupKey<FunctionDTO> dimensionAsKey : dimensionsAsKeys) {
-                    if (!tablesMappedByDimensionAsKeys.containsKey(dimensionAsKey)) {
-                        SelectionTable<?> table = new SelectionTable<>(dimensionAsKey.getValue());
-                        table.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
-                            @Override
-                            public void onSelectionChange(SelectionChangeEvent event) {
-                                notifySelectionChanged();
-                            }
-                        });
-                        
-                        tablesMappedByDimensionAsKeys.put(dimensionAsKey, table);
-                    }
+                if (settings.isRefreshAutomatically()) {
+                    timer.schedule(settings.getRefreshIntervalInMilliseconds());
                 }
-                
-                List<GenericGroupKey<FunctionDTO>> sortedDimensions = new ArrayList<>(tablesMappedByDimensionAsKeys.keySet());
-                Collections.sort(sortedDimensions, new Comparator<GenericGroupKey<FunctionDTO>>() {
-                    @Override
-                    public int compare(GenericGroupKey<FunctionDTO> k1, GenericGroupKey<FunctionDTO> k2) {
-                        return k1.getValue().compareTo(k2.getValue());
-                    }
-                });
-                tablesPanel.clear();
-                for (GenericGroupKey<FunctionDTO> dimension : sortedDimensions) {
-                    tablesPanel.add(tablesMappedByDimensionAsKeys.get(dimension));
-                }
-
-                updateTables();
-                doLayout(Window.getClientWidth(), Window.getClientHeight());
             }
         });
     }
 
+    private void updateAvailableTables(Collection<GenericGroupKey<FunctionDTO>> dimensionsAsKeys) {
+        Collection<GenericGroupKey<FunctionDTO>> dimensionTablesToBeRemoved = new HashSet<>(tablesMappedByDimensionAsKeys.keySet());
+        dimensionTablesToBeRemoved.removeAll(dimensionsAsKeys);
+        for (GenericGroupKey<FunctionDTO> dimensionToBeRemoved : dimensionTablesToBeRemoved) {
+            tablesMappedByDimensionAsKeys.remove(dimensionToBeRemoved);
+        }
+        
+        for (GenericGroupKey<FunctionDTO> dimensionAsKey : dimensionsAsKeys) {
+            if (!tablesMappedByDimensionAsKeys.containsKey(dimensionAsKey)) {
+                SelectionTable<?> table = new SelectionTable<>(dimensionAsKey.getValue());
+                table.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
+                    @Override
+                    public void onSelectionChange(SelectionChangeEvent event) {
+                        notifySelectionChanged();
+                    }
+                });
+                
+                tablesMappedByDimensionAsKeys.put(dimensionAsKey, table);
+            }
+        }
+        
+        List<GenericGroupKey<FunctionDTO>> sortedDimensions = new ArrayList<>(tablesMappedByDimensionAsKeys.keySet());
+        Collections.sort(sortedDimensions, new Comparator<GenericGroupKey<FunctionDTO>>() {
+            @Override
+            public int compare(GenericGroupKey<FunctionDTO> k1, GenericGroupKey<FunctionDTO> k2) {
+                return k1.getValue().compareTo(k2.getValue());
+            }
+        });
+        tablesPanel.clear();
+        for (GenericGroupKey<FunctionDTO> dimension : sortedDimensions) {
+            tablesPanel.add(tablesMappedByDimensionAsKeys.get(dimension));
+        }
+
+        doLayout(Window.getClientWidth(), Window.getClientHeight());
+    }
+
     private void doLayout(int newWindowWidth, int newWindowHeight) {
         int absoluteWidth = (int) ((newWindowWidth - widthMargin) * relativeWidthInPercent);
         int absoluteHeight = (int) (newWindowHeight * relativeHeightInPercent);
@@ -169,48 +181,28 @@ public class RefreshingSelectionTablesPanel implements SelectionProvider<Refresh
         }
     }
 
-    private void updateTables() {
-        Collection<FunctionDTO> dimensions = new HashSet<>();
+    private boolean updateTableValues(Map<GroupKey, Set<Object>> newValues) {
+        boolean tableContentChanged = false;
         for (GenericGroupKey<FunctionDTO> dimensionAsKey : tablesMappedByDimensionAsKeys.keySet()) {
-            dimensions.add(dimensionAsKey.getValue());
+            List<?> sortedDimensionValues = new ArrayList<>();
+            if (newValues.containsKey(dimensionAsKey)) {
+                sortedDimensionValues = new ArrayList<>(newValues.get(dimensionAsKey));
+                Collections.sort(sortedDimensionValues, new Comparator<Object>() {
+                    @Override
+                    public int compare(Object o1, Object o2) {
+                        return o1.toString().compareTo(o2.toString());
+                    }
+                });
+            }
+
+            boolean currentTableContentChanged = tablesMappedByDimensionAsKeys.get(dimensionAsKey).updateContent(
+                    sortedDimensionValues);
+            if (!tableContentChanged) {
+                tableContentChanged = currentTableContentChanged;
+            }
         }
-        
-        dataMiningService.getDimensionValuesFor(dimensions, new AsyncCallback<QueryResult<Set<Object>>>() {
-            @Override
-            public void onFailure(Throwable caught) {
-                errorReporter.reportError("Error fetching the dimension values from the server: " + caught.getMessage());
-            }
-            @Override
-            public void onSuccess(QueryResult<Set<Object>> result) {
-                boolean tableContentChanged = false;
-                for (GenericGroupKey<FunctionDTO> dimensionAsKey : tablesMappedByDimensionAsKeys.keySet()) {
-                    List<?> sortedDimensionValues = new ArrayList<>();
-                    if (result.getResults().containsKey(dimensionAsKey)) {
-                        sortedDimensionValues = new ArrayList<>(result.getResults().get(dimensionAsKey));
-                        Collections.sort(sortedDimensionValues, new Comparator<Object>() {
-                            @Override
-                            public int compare(Object o1, Object o2) {
-                                return o1.toString().compareTo(o2.toString());
-                            }
-                        });
-                    }
-                    
-                    boolean currentTableContentChanged = tablesMappedByDimensionAsKeys.get(dimensionAsKey).updateContent(sortedDimensionValues);
-                    if (!tableContentChanged) {
-                        tableContentChanged = currentTableContentChanged;
-                    }
-                }
-                
-                if (settings.isRerunQueryAfterRefresh() && tableContentChanged) {
-                    notifySelectionChanged();
-                    // TODO query is executed, before the data is ready to be analyzed
-                    // TODO does this error still appear with the new concept?
-                }
-                if (settings.isRefreshAutomatically()) {
-                    timer.schedule(settings.getRefreshIntervalInMilliseconds());
-                }
-            }
-        });
+
+        return tableContentChanged;
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/SimpleDataRetrieverChainDefinitionProvider.java

@@ -0,0 +1,184 @@
+package com.sap.sailing.gwt.ui.datamining.selection;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+import com.google.gwt.event.logical.shared.ValueChangeEvent;
+import com.google.gwt.event.logical.shared.ValueChangeHandler;
+import com.google.gwt.i18n.client.LocaleInfo;
+import com.google.gwt.text.shared.AbstractRenderer;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.google.gwt.user.client.ui.ValueListBox;
+import com.google.gwt.user.client.ui.HorizontalPanel;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.Widget;
+import com.sap.sailing.gwt.ui.client.ErrorReporter;
+import com.sap.sailing.gwt.ui.client.StringMessages;
+import com.sap.sailing.gwt.ui.client.shared.components.SettingsDialogComponent;
+import com.sap.sailing.gwt.ui.datamining.DataMiningServiceAsync;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionChangedListener;
+import com.sap.sailing.gwt.ui.datamining.DataRetrieverChainDefinitionProvider;
+import com.sap.sailing.gwt.ui.datamining.StatisticChangedListener;
+import com.sap.sailing.gwt.ui.datamining.StatisticProvider;
+import com.sap.sse.datamining.shared.QueryDefinition;
+import com.sap.sse.datamining.shared.components.AggregatorType;
+import com.sap.sse.datamining.shared.dto.FunctionDTO;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
+
+public class SimpleDataRetrieverChainDefinitionProvider implements DataRetrieverChainDefinitionProvider,
+                                                                   StatisticChangedListener {
+    
+    private final StringMessages stringMessages;
+    private final DataMiningServiceAsync dataMiningService;
+    private final ErrorReporter errorReporter;
+    private final Set<DataRetrieverChainDefinitionChangedListener> listeners;
+    
+    private FunctionDTO currentStatisticToCalculate;
+    
+    private final HorizontalPanel mainPanel;
+    private final ValueListBox<DataRetrieverChainDefinitionDTO> retrieverChainsListBox;
+
+    public SimpleDataRetrieverChainDefinitionProvider(StringMessages stringMessages, DataMiningServiceAsync dataMiningService, ErrorReporter errorReporter,
+                                                      StatisticProvider statisticProvider) {
+        this.stringMessages = stringMessages;
+        this.dataMiningService = dataMiningService;
+        this.errorReporter = errorReporter;
+        listeners = new HashSet<>();
+        currentStatisticToCalculate = null;
+        
+        mainPanel = new HorizontalPanel();
+        mainPanel.setSpacing(5);
+        mainPanel.add(new Label(this.stringMessages.retrieveWith()));
+        
+        retrieverChainsListBox = createRetrieverChainsListBox();
+        mainPanel.add(retrieverChainsListBox);
+        
+        statisticProvider.addStatisticChangedListener(this);
+    }
+
+    private ValueListBox<DataRetrieverChainDefinitionDTO> createRetrieverChainsListBox() {
+        ValueListBox<DataRetrieverChainDefinitionDTO> retrieverChainsListBox = new ValueListBox<>(new AbstractRenderer<DataRetrieverChainDefinitionDTO>() {
+            @Override
+            public String render(DataRetrieverChainDefinitionDTO retrieverChain) {
+                return retrieverChain.getName();
+            }
+            
+        });
+        retrieverChainsListBox.addValueChangeHandler(new ValueChangeHandler<DataRetrieverChainDefinitionDTO>() {
+            @Override
+            public void onValueChange(ValueChangeEvent<DataRetrieverChainDefinitionDTO> event) {
+                notifyListeners();
+            }
+        });
+        return retrieverChainsListBox;
+    }
+    
+    @Override
+    public void statisticChanged(FunctionDTO newStatisticToCalculate, AggregatorType newAggregatorType) {
+        if (!Objects.equals(currentStatisticToCalculate, newStatisticToCalculate)) {
+            String currentSourceType = currentStatisticToCalculate == null ? null : currentStatisticToCalculate.getSourceTypeName();
+            currentStatisticToCalculate = newStatisticToCalculate;
+            if (!Objects.equals(currentSourceType, newStatisticToCalculate.getSourceTypeName())) {
+                updateAvailableRetrieverChains();
+            }
+        }
+    }
+    
+    private void updateAvailableRetrieverChains() {
+        dataMiningService.getDataRetrieverChainDefinitionsFor(currentStatisticToCalculate, LocaleInfo.getCurrentLocale().getLocaleName(),
+                new AsyncCallback<Collection<DataRetrieverChainDefinitionDTO>>() {
+                    @Override
+                    public void onSuccess(Collection<DataRetrieverChainDefinitionDTO> dataRetrieverChainDefinitions) {
+                        if (!dataRetrieverChainDefinitions.isEmpty()) {
+                            List<DataRetrieverChainDefinitionDTO> sortedRetrieverChains = new ArrayList<>(dataRetrieverChainDefinitions);
+                            Collections.sort(sortedRetrieverChains);
+                            
+                            DataRetrieverChainDefinitionDTO currentRetrieverChain = getDataRetrieverChainDefinition();
+                            DataRetrieverChainDefinitionDTO retrieverChainToBeSelected = sortedRetrieverChains.contains(currentRetrieverChain) ?
+                                                                                            currentRetrieverChain :
+                                                                                            sortedRetrieverChains.get(0);
+                            
+                            retrieverChainsListBox.setValue(retrieverChainToBeSelected);
+                            retrieverChainsListBox.setAcceptableValues(sortedRetrieverChains);
+                            
+                            if (!retrieverChainToBeSelected.equals(currentRetrieverChain)) {
+                                notifyListeners();
+                            }
+                        } else {
+                            retrieverChainsListBox.setValue(null);
+                            retrieverChainsListBox.setAcceptableValues(new ArrayList<DataRetrieverChainDefinitionDTO>());
+                            notifyListeners();
+                        }
+                    }
+                    @Override
+                    public void onFailure(Throwable caught) {
+                        errorReporter.reportError("Error retrieving the available DataRetrieverChainDefinitions: " + caught.getMessage());
+                    }
+                });
+    }
+
+    @Override
+    public DataRetrieverChainDefinitionDTO getDataRetrieverChainDefinition() {
+        return retrieverChainsListBox.getValue();
+    }
+
+    @Override
+    public void addDataRetrieverChainDefinitionChangedListener(DataRetrieverChainDefinitionChangedListener listener) {
+        listeners.add(listener);
+    }
+    
+    private void notifyListeners() {
+        for (DataRetrieverChainDefinitionChangedListener listener : listeners) {
+            listener.dataRetrieverChainDefinitionChanged(getDataRetrieverChainDefinition());
+        }
+    }
+
+    @Override
+    public void applyQueryDefinition(QueryDefinition queryDefinition) {
+        retrieverChainsListBox.setValue(queryDefinition.getDataRetrieverChainDefinition(), false);
+    }
+
+    @Override
+    public String getLocalizedShortName() {
+        return SimpleDataRetrieverChainDefinitionProvider.class.getSimpleName();
+    }
+
+    @Override
+    public Widget getEntryWidget() {
+        return mainPanel;
+    }
+
+    @Override
+    public boolean isVisible() {
+        return mainPanel.isVisible();
+    }
+
+    @Override
+    public void setVisible(boolean visibility) {
+        mainPanel.setVisible(visibility);
+    }
+
+    @Override
+    public String getDependentCssClassName() {
+        return "simpleDataRetrieverChainDefinition";
+    }
+
+    @Override
+    public boolean hasSettings() {
+        return false;
+    }
+
+    @Override
+    public SettingsDialogComponent<Object> getSettingsDialogComponent() {
+        return null;
+    }
+
+    @Override
+    public void updateSettings(Object newSettings) { }
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/SimpleStatisticProvider.java

@@ -35,9 +35,12 @@ public class SimpleStatisticProvider implements StatisticProvider {
     private final ErrorReporter errorReporter;
     private final Set<StatisticChangedListener> listeners;
     
+    private final ExtractionFunctionSet extractionFunctionSet;
+    
     private final HorizontalPanel mainPanel;
-    private final ValueListBox<FunctionDTO> extractionFunctionListBox;
+    private final ValueListBox<StrippedFunctionDTO> extractionFunctionListBox;
     private final ValueListBox<AggregatorType> aggregatorListBox;
+    private final ValueListBox<String> baseDataTypeListBox;
 
     public SimpleStatisticProvider(StringMessages stringMessages, DataMiningServiceAsync dataMiningService, ErrorReporter errorReporter) {
         this.stringMessages = stringMessages;
@@ -45,6 +48,8 @@ public class SimpleStatisticProvider implements StatisticProvider {
         this.errorReporter = errorReporter;
         listeners = new HashSet<StatisticChangedListener>();
         
+        extractionFunctionSet = new ExtractionFunctionSet();
+        
         mainPanel = new HorizontalPanel();
         mainPanel.setSpacing(5);
 
@@ -55,6 +60,10 @@ public class SimpleStatisticProvider implements StatisticProvider {
         aggregatorListBox = createAggregatorListBox();
         HorizontalPanel aggregatorPanel = surroundAggregatorListBoxWithBraces(aggregatorListBox);
         mainPanel.add(aggregatorPanel);
+        
+        mainPanel.add(new Label(this.stringMessages.basedOn()));
+        baseDataTypeListBox = createBaseDataTypeListBox();
+        mainPanel.add(baseDataTypeListBox);
 
         updateExtractionFunctions();
     }
@@ -64,22 +73,26 @@ public class SimpleStatisticProvider implements StatisticProvider {
             
             @Override
             public void onSuccess(Collection<FunctionDTO> extractionFunctions) {
+                extractionFunctionSet.clear();
+                
                 if (!extractionFunctions.isEmpty()) {
-                    List<FunctionDTO> acceptableValues = new ArrayList<>(extractionFunctions);
-                    Collections.sort(acceptableValues);
-                    
-                    FunctionDTO currentExtractionFunction = getStatisticToCalculate();
-                    FunctionDTO valueToBeSelected = acceptableValues.contains(currentExtractionFunction) ? currentExtractionFunction
-                                                                                                         : acceptableValues.iterator().next();
-                    extractionFunctionListBox.setValue(valueToBeSelected);
-                    extractionFunctionListBox.setAcceptableValues(acceptableValues);
-                    
-                    if (!valueToBeSelected.equals(currentExtractionFunction)) {
+                    extractionFunctionSet.addAll(extractionFunctions);
+
+                    StrippedFunctionDTO previousExtractionFunction = extractionFunctionListBox.getValue();
+                    updateExtractionFunctionListBox();
+                    StrippedFunctionDTO newExtractionFunction = extractionFunctionListBox.getValue();
+
+                    String previousBaseDataType = baseDataTypeListBox.getValue();
+                    updateBaseDataTypeListBox();
+                    String newBaseDataType = baseDataTypeListBox.getValue();
+
+                    if (!newExtractionFunction.equals(previousExtractionFunction) ||
+                        !newBaseDataType.equals(previousBaseDataType)) {
                         notifyListeners();
                     }
                 } else {
-                    extractionFunctionListBox.setValue(null);
-                    extractionFunctionListBox.setAcceptableValues(new ArrayList<FunctionDTO>());
+                    clearListBox(extractionFunctionListBox);
+                    clearListBox(baseDataTypeListBox);
                     notifyListeners();
                 }
             }
@@ -91,21 +104,58 @@ public class SimpleStatisticProvider implements StatisticProvider {
         });
     }
 
-    private ValueListBox<FunctionDTO> createExtractionFunctionListBox() {
-        ValueListBox<FunctionDTO> extractionFunctionListBox = new ValueListBox<FunctionDTO>(new AbstractObjectRenderer<FunctionDTO>() {
+    private void updateExtractionFunctionListBox() {
+        List<StrippedFunctionDTO> acceptableFunctions = new ArrayList<>(extractionFunctionSet.getStrippedFunctionDTOs());
+        Collections.sort(acceptableFunctions);
+        updateListBox(extractionFunctionListBox, acceptableFunctions);
+    }
+
+    private void updateBaseDataTypeListBox() {
+        List<String> acceptableBaseDataTypes = new ArrayList<>(extractionFunctionSet.getSourceTypeNames(extractionFunctionListBox.getValue()));
+        Collections.sort(acceptableBaseDataTypes);
+        updateListBox(baseDataTypeListBox, acceptableBaseDataTypes);
+    }
+    
+    private <T> void updateListBox(ValueListBox<T> listBox, Collection<T> acceptableValues) {
+        T currentValue = listBox.getValue();
+        T valueToBeSelected = acceptableValues.contains(currentValue) ? currentValue : acceptableValues.iterator().next();
+        
+        listBox.setValue(valueToBeSelected);
+        listBox.setAcceptableValues(acceptableValues);
+    }
+
+    private <T> void clearListBox(ValueListBox<T> listBox) {
+        listBox.setValue(null);
+        listBox.setAcceptableValues(new ArrayList<T>());
+    }
+
+    private ValueListBox<StrippedFunctionDTO> createExtractionFunctionListBox() {
+        ValueListBox<StrippedFunctionDTO> extractionFunctionListBox = new ValueListBox<>(new AbstractObjectRenderer<StrippedFunctionDTO>() {
             @Override
-            protected String convertObjectToString(FunctionDTO function) {
+            protected String convertObjectToString(StrippedFunctionDTO function) {
                 return function.getDisplayName();
             }
         });
-        extractionFunctionListBox.addValueChangeHandler(new ValueChangeHandler<FunctionDTO>() {
+        extractionFunctionListBox.addValueChangeHandler(new ValueChangeHandler<StrippedFunctionDTO>() {
             @Override
-            public void onValueChange(ValueChangeEvent<FunctionDTO> event) {
+            public void onValueChange(ValueChangeEvent<StrippedFunctionDTO> event) {
+                updateBaseDataTypeListBox();
                 notifyListeners();
             }
         });
         return extractionFunctionListBox;
     }
+
+    private ValueListBox<String> createBaseDataTypeListBox() {
+        ValueListBox<String> baseDataTypeListBox = new ValueListBox<>(new SimpleObjectRenderer<String>());
+        baseDataTypeListBox.addValueChangeHandler(new ValueChangeHandler<String>() {
+            @Override
+            public void onValueChange(ValueChangeEvent<String> event) {
+                notifyListeners();
+            }
+        });
+        return baseDataTypeListBox;
+    }
     
     private ValueListBox<AggregatorType> createAggregatorListBox() {
         ValueListBox<AggregatorType> aggregatorListBox = new ValueListBox<AggregatorType>(new SimpleObjectRenderer<AggregatorType>());
@@ -136,7 +186,7 @@ public class SimpleStatisticProvider implements StatisticProvider {
 
     @Override
     public void applyQueryDefinition(QueryDefinition queryDefinition) {
-        extractionFunctionListBox.setValue(queryDefinition.getStatisticToCalculate(), false);
+        extractionFunctionListBox.setValue(new StrippedFunctionDTO(queryDefinition.getStatisticToCalculate()), false);
         aggregatorListBox.setValue(queryDefinition.getAggregatorType(), false);
     }
 
@@ -153,7 +203,7 @@ public class SimpleStatisticProvider implements StatisticProvider {
 
     @Override
     public FunctionDTO getStatisticToCalculate() {
-        return extractionFunctionListBox.getValue();
+        return extractionFunctionSet.getFunctionDTO(extractionFunctionListBox.getValue(), baseDataTypeListBox.getValue());
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/datamining/selection/StrippedFunctionDTO.java

@@ -0,0 +1,78 @@
+package com.sap.sailing.gwt.ui.datamining.selection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.sap.sse.datamining.shared.dto.FunctionDTO;
+
+public class StrippedFunctionDTO implements Comparable<StrippedFunctionDTO> {
+
+    private final String returnTypeName;
+    private final String displayName;
+    private final List<String> parameterTypeNames;
+    private final boolean isDimension;
+    
+    private final int ordinal;
+
+    public StrippedFunctionDTO(FunctionDTO functionDTO) {
+        returnTypeName = functionDTO.getReturnTypeName();
+        displayName = functionDTO.getDisplayName();
+        parameterTypeNames = new ArrayList<>(functionDTO.getParameterTypeNames());
+        isDimension = functionDTO.isDimension();
+        ordinal = functionDTO.getOrdinal();
+    }
+    
+    public String getDisplayName() {
+        return displayName;
+    }
+    
+    public int getOrdinal() {
+        return ordinal;
+    }
+    
+    @Override
+    public int compareTo(StrippedFunctionDTO f) {
+        return Integer.compare(this.getOrdinal(), f.getOrdinal());
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((displayName == null) ? 0 : displayName.hashCode());
+        result = prime * result + (isDimension ? 1231 : 1237);
+        result = prime * result + ((parameterTypeNames == null) ? 0 : parameterTypeNames.hashCode());
+        result = prime * result + ((returnTypeName == null) ? 0 : returnTypeName.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        StrippedFunctionDTO other = (StrippedFunctionDTO) obj;
+        if (displayName == null) {
+            if (other.displayName != null)
+                return false;
+        } else if (!displayName.equals(other.displayName))
+            return false;
+        if (isDimension != other.isDimension)
+            return false;
+        if (parameterTypeNames == null) {
+            if (other.parameterTypeNames != null)
+                return false;
+        } else if (!parameterTypeNames.equals(other.parameterTypeNames))
+            return false;
+        if (returnTypeName == null) {
+            if (other.returnTypeName != null)
+                return false;
+        } else if (!returnTypeName.equals(other.returnTypeName))
+            return false;
+        return true;
+    }
+
+}

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

@@ -14,6 +14,7 @@ import com.sap.sailing.datamining.shared.SailingDataMiningSerializationDummy;
 import com.sap.sailing.gwt.ui.datamining.DataMiningService;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sse.datamining.DataMiningServer;
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
 import com.sap.sse.datamining.Query;
 import com.sap.sse.datamining.factories.FunctionDTOFactory;
 import com.sap.sse.datamining.functions.Function;
@@ -22,19 +23,28 @@ import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.QueryResult;
 import com.sap.sse.datamining.shared.SSEDataMiningSerializationDummy;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public class DataMiningServiceImpl extends RemoteServiceServlet implements DataMiningService {
     private static final long serialVersionUID = -7951930891674894528L;
 
     private final BundleContext context;
 
+    private final SailingDataMiningFactory sailingDataMiningFactory;
+    private final FunctionDTOFactory functionDTOFactory;
+
     private final ServiceTracker<DataMiningServer, DataMiningServer> dataMiningServerTracker;
     private final ServiceTracker<RacingEventService, RacingEventService> racingEventServiceTracker;
     
     public DataMiningServiceImpl() {
         context = Activator.getDefault();
+        
         dataMiningServerTracker = createAndOpenDataMiningServerTracker(context);
         racingEventServiceTracker = createAndOpenRacingEventServiceTracker(context);
+        
+        sailingDataMiningFactory = new SailingDataMiningFactory(getDataMiningServer().getFunctionProvider(),
+                                                                getDataMiningServer().getDataRetrieverChainDefinitionRegistry());
+        functionDTOFactory = new FunctionDTOFactory();
     }
 
     private ServiceTracker<DataMiningServer, DataMiningServer> createAndOpenDataMiningServerTracker(
@@ -68,37 +78,62 @@ public class DataMiningServiceImpl extends RemoteServiceServlet implements DataM
 
     @Override
     public Collection<FunctionDTO> getDimensionsFor(FunctionDTO statisticToCalculate, String localeInfoName) {
-        Class<?> dataTypeBaseClass = getBaseClassFor(statisticToCalculate);
-        Collection<Function<?>> dimensions = getDataMiningServer().getFunctionProvider().getDimensionsFor(dataTypeBaseClass);
+        Class<?> baseDataType = getBaseDataType(statisticToCalculate);
+        Collection<Function<?>> dimensions = getDataMiningServer().getFunctionProvider().getDimensionsFor(baseDataType);
         return functionsAsFunctionDTOs(dimensions, localeInfoName);
     }
     
-    private Class<?> getBaseClassFor(FunctionDTO statisticToCalculate) {
+    @Override
+    public Collection<DataRetrieverChainDefinitionDTO> getDataRetrieverChainDefinitionsFor(FunctionDTO statisticToCalculate, String localeInfoName) {
+        Class<?> baseDataType = getBaseDataType(statisticToCalculate);
+        return dataRetrieverChainDefinitionsAsDTOs(getDataMiningServer().getDataRetrieverChainDefinitionRegistry().getDataRetrieverChainDefinitions(RacingEventService.class, baseDataType), localeInfoName);
+    }
+    
+    private Collection<DataRetrieverChainDefinitionDTO> dataRetrieverChainDefinitionsAsDTOs(
+            Collection<DataRetrieverChainDefinition<RacingEventService>> dataRetrieverChainDefinitions, String localeInfoName) {
+        Locale locale = DataMiningStringMessages.Util.getLocaleFor(localeInfoName);
+        DataMiningStringMessages dataMiningStringMessages = getDataMiningServer().getStringMessages();
+        
+        Collection<DataRetrieverChainDefinitionDTO> DTOs = new ArrayList<>();
+        for (DataRetrieverChainDefinition<RacingEventService> dataRetrieverChainDefinition : dataRetrieverChainDefinitions) {
+            DTOs.add(new DataRetrieverChainDefinitionDTO(dataRetrieverChainDefinition.getUUID(), dataRetrieverChainDefinition.getLocalizedName(locale, dataMiningStringMessages),
+                                                         dataRetrieverChainDefinition.getDataSourceType().getSimpleName(), dataRetrieverChainDefinition.getRetrievedDataType().getSimpleName()));
+        }
+        return DTOs;
+    }
+
+    private Class<?> getBaseDataType(FunctionDTO statisticToCalculate) {
         Function<?> function = getDataMiningServer().getFunctionProvider().getFunctionForDTO(statisticToCalculate);
         return function.getDeclaringType();
     }
-
+    
     private Collection<FunctionDTO> functionsAsFunctionDTOs(Collection<Function<?>> functions, String localeInfoName) {
         Locale locale = DataMiningStringMessages.Util.getLocaleFor(localeInfoName);
         DataMiningStringMessages dataMiningStringMessages = getDataMiningServer().getStringMessages();
         
         Collection<FunctionDTO> functionDTOs = new ArrayList<FunctionDTO>();
         for (Function<?> function : functions) {
-            functionDTOs.add(FunctionDTOFactory.createFunctionDTO(function, locale, dataMiningStringMessages));
+            functionDTOs.add(functionDTOFactory.createFunctionDTO(function, dataMiningStringMessages, locale));
         }
         return functionDTOs;
     }
     
+//    @Override
+//    public QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception {
+//        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), null, dimensions);
+//        return dimensionValuesQuery.run();
+//    }
     @Override
-    public QueryResult<Set<Object>> getDimensionValuesFor(Collection<FunctionDTO> dimensions) throws Exception {
-        Query<Set<Object>> dimensionValuesQuery = SailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), dimensions, getDataMiningServer().getFunctionProvider());
+    public QueryResult<Set<Object>> getDimensionValuesFor(DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition,
+            String localeInfoName) throws Exception {
+        Query<Set<Object>> dimensionValuesQuery = sailingDataMiningFactory.createDimensionValuesQuery(getRacingEventService(), dataRetrieverChainDefinition, localeInfoName);
         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);
         return query.run();
     }
     

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/Message.java

@@ -1,6 +0,0 @@
-package com.sap.sse.datamining.shared;
-
-public enum Message {
-    Average, Median, Sum, Distance, Speed, Knots, Meters, ResultSignifier, SignifierInUnit, Collecting
-
-}

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/QueryDefinition.java

@@ -6,17 +6,18 @@ import java.util.Map;
 
 import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public interface QueryDefinition extends Serializable {
     
     public String getLocaleInfoName();
     
+    public FunctionDTO getStatisticToCalculate();
+    public AggregatorType getAggregatorType();
+    
+    public DataRetrieverChainDefinitionDTO getDataRetrieverChainDefinition();
     public Map<FunctionDTO, Iterable<? extends Serializable>> getFilterSelection();
     
     public List<FunctionDTO> getDimensionsToGroupBy();
-    
-    public FunctionDTO getStatisticToCalculate();
-    
-    public AggregatorType getAggregatorType();
 
 }

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/Unit.java

@@ -1,7 +1,7 @@
 package com.sap.sse.datamining.shared;
 
 public enum Unit {
-	
-	None, Knots, Meters
+
+    None, Knots, Meters
 
 }

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/components/AggregatorType.java

@@ -1,19 +1,5 @@
 package com.sap.sse.datamining.shared.components;
 
-import com.sap.sse.datamining.shared.Message;
-
 public enum AggregatorType {
     Sum, Average, Median;
-
-    public Message getNameMessage() {
-        switch (this) {
-        case Average:
-            return Message.Average;
-        case Median:
-            return Message.Median;
-        case Sum:
-            return Message.Sum;
-        };
-        throw new IllegalArgumentException("No message available for the aggregator type '" + this + "'");
-    }
 }

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/components/ElementType.java

@@ -1,5 +0,0 @@
-package com.sap.sse.datamining.shared.components;
-
-public enum ElementType {
-    Integer, Double
-}

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/components/GrouperType.java

@@ -1,5 +0,0 @@
-package com.sap.sse.datamining.shared.components;
-
-public enum GrouperType {
-    Dimensions
-}

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/dto/FunctionDTO.java

@@ -5,15 +5,17 @@ import java.util.List;
 
 public interface FunctionDTO extends Serializable, Comparable<FunctionDTO> {
 
-    public boolean isDimension();
-
-    public String getDisplayName();
-
-    public List<String> getParameters();
+    public String getSourceTypeName();
 
     public String getReturnTypeName();
 
-    public String getSourceTypeName();
+    public String getFunctionName();
+
+    public String getDisplayName();
+
+    public List<String> getParameterTypeNames();
+
+    public boolean isDimension();
     
     public int getOrdinal();
 

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/impl/QueryDefinitionImpl.java

@@ -9,15 +9,17 @@ import java.util.Map;
 import com.sap.sse.datamining.shared.QueryDefinition;
 import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
+import com.sap.sse.datamining.shared.impl.dto.DataRetrieverChainDefinitionDTO;
 
 public class QueryDefinitionImpl implements QueryDefinition {
     private static final long serialVersionUID = -6438771277564908352L;
     
     private String localeInfoName;
-    private Map<FunctionDTO, Iterable<? extends Serializable>> filterSelection;
-    private List<FunctionDTO> dimensionsToGroupBy;
     private FunctionDTO statisticToCalculate;
     private AggregatorType aggregatorType;
+    private List<FunctionDTO> dimensionsToGroupBy;
+    private DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition;
+    private Map<FunctionDTO, Iterable<? extends Serializable>> filterSelection;
     
     /**
      * <b>Constructor for the GWT-Serialization. Don't use this!</b>
@@ -25,12 +27,13 @@ public class QueryDefinitionImpl implements QueryDefinition {
     @Deprecated
     QueryDefinitionImpl() { }
 
-    public QueryDefinitionImpl(String localeInfoName, FunctionDTO statisticToCalculate, AggregatorType aggregatorType) {
+    public QueryDefinitionImpl(String localeInfoName, FunctionDTO statisticToCalculate, AggregatorType aggregatorType, DataRetrieverChainDefinitionDTO dataRetrieverChainDefinition) {
         this.localeInfoName = localeInfoName;
-        this.filterSelection = new HashMap<FunctionDTO, Iterable<? extends Serializable>>();
-        this.dimensionsToGroupBy = new ArrayList<FunctionDTO>();
         this.statisticToCalculate = statisticToCalculate;
         this.aggregatorType = aggregatorType;
+        this.dataRetrieverChainDefinition = dataRetrieverChainDefinition;
+        this.filterSelection = new HashMap<FunctionDTO, Iterable<? extends Serializable>>();
+        this.dimensionsToGroupBy = new ArrayList<FunctionDTO>();
     }
     
     public void setFilterSelectionFor(FunctionDTO dimension, Iterable<? extends Serializable> selection) {
@@ -45,6 +48,11 @@ public class QueryDefinitionImpl implements QueryDefinition {
     public String getLocaleInfoName() {
         return localeInfoName;
     }
+    
+    @Override
+    public DataRetrieverChainDefinitionDTO getDataRetrieverChainDefinition() {
+        return dataRetrieverChainDefinition;
+    }
 
     @Override
     public Map<FunctionDTO, Iterable<? extends Serializable>> getFilterSelection() {

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/impl/dto/DataRetrieverChainDefinitionDTO.java

@@ -0,0 +1,48 @@
+package com.sap.sse.datamining.shared.impl.dto;
+
+import java.io.Serializable;
+import java.util.UUID;
+
+public class DataRetrieverChainDefinitionDTO implements Serializable, Comparable<DataRetrieverChainDefinitionDTO> {
+    private static final long serialVersionUID = 7806173601799997214L;
+    
+    private UUID id;
+    private String name;
+    private String dataSourceTypeName;
+    private String retrievedDataTypeName;
+
+    /**
+     * <b>Constructor for the GWT-Serialization. Don't use this!</b>
+     */
+    @Deprecated
+    DataRetrieverChainDefinitionDTO() { }
+
+    public DataRetrieverChainDefinitionDTO(UUID id, String name, String dataSourceTypeName, String retrievedDataTypeName) {
+        this.id = id;
+        this.name = name;
+        this.dataSourceTypeName = dataSourceTypeName;
+        this.retrievedDataTypeName = retrievedDataTypeName;
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDataSourceTypeName() {
+        return dataSourceTypeName;
+    }
+
+    public String getRetrievedDataTypeName() {
+        return retrievedDataTypeName;
+    }
+
+    @Override
+    public int compareTo(DataRetrieverChainDefinitionDTO d) {
+        return this.getName().compareTo(d.getName());
+    }
+    
+}

java/com.sap.sse.datamining.shared/src/com/sap/sse/datamining/shared/impl/dto/FunctionDTOImpl.java

@@ -47,9 +47,14 @@ public class FunctionDTOImpl implements FunctionDTO {
     }
 
     @Override
-    public List<String> getParameters() {
+    public List<String> getParameterTypeNames() {
         return parameterTypeNames;
     }
+    
+    @Override
+    public String getFunctionName() {
+        return functionName;
+    }
 
     @Override
     public String getDisplayName() {

java/com.sap.sse.datamining.test/resources/stringmessages/Test_StringMessages_de.properties

@@ -4,4 +4,5 @@ dimension = dimension-deutsch
 value = sideEffectFreeValue-deutsch
 regattaName = Regatta Name
 crossSum = Quersumme
-Name = Name
+Name = Name
+Year = Jahr

java/com.sap.sse.datamining.test/resources/stringmessages/Test_StringMessages_en.properties

@@ -4,4 +4,5 @@ dimension = dimension-english
 value = sideEffectFreeValue-english
 regattaName = Regatta Name
 crossSum = Cross Sum
-Name = Name
+Name = Name
+Year=Year

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

@@ -1,91 +0,0 @@
-package com.sap.sse.datamining.impl;
-
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.sap.sse.datamining.ClassesWithFunctionsProvider;
-import com.sap.sse.datamining.DataMiningServer;
-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.functions.RegistryFunctionProvider;
-import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegContext;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContext;
-import com.sap.sse.datamining.test.util.ExpectedFunctionRegistryUtil;
-import com.sap.sse.datamining.test.util.TestsUtil;
-
-public class TestDataMiningServer {
-    
-    private static ExpectedFunctionRegistryUtil expectedFunctionRegistryUtil;
-
-    @BeforeClass
-    public static void intializeExpectedFunctions() throws NoSuchMethodException, SecurityException {
-        expectedFunctionRegistryUtil = new ExpectedFunctionRegistryUtil();
-    }
-
-    @Test
-    public void testThatTheFunctionRegistryIsAllwaysUpToDate() {
-        FunctionRegistry registry = new SimpleFunctionRegistry();
-        FunctionProvider provider = new RegistryFunctionProvider(registry);
-        OpenClassesWithFunctionsProvider classesWithFunctionsProvider = new OpenClassesWithFunctionsProvider();
-        DataMiningServer server = new DataMiningServerImpl(TestsUtil.getTestStringMessages(), registry, provider, classesWithFunctionsProvider);
-        
-        assertThat("The function registry should be empty.",
-                   server.getFunctionRegistry().getAllFunctions().isEmpty(),
-                   is(true));
-        
-        classesWithFunctionsProvider.internalClassesWithMarkedMethods.add(Test_HasLegContext.class);
-        Collection<Function<?>> expectedFunctions = new HashSet<>();
-        expectedFunctions.addAll(expectedFunctionRegistryUtil.getExpectedFunctionsFor(Test_HasLegContext.class));
-        expectedFunctions.addAll(expectedFunctionRegistryUtil.getExpectedFunctionsFor(Test_HasRaceContext.class));
-        assertThat(server.getFunctionRegistry().getAllFunctions(), is(expectedFunctions));
-        
-        classesWithFunctionsProvider.internalClassesWithMarkedMethods.remove(Test_HasLegContext.class);
-        classesWithFunctionsProvider.internalClassesWithMarkedMethods.add(Test_HasRaceContext.class);
-        expectedFunctions = expectedFunctionRegistryUtil.getExpectedFunctionsFor(Test_HasRaceContext.class);
-        assertThat(server.getFunctionRegistry().getAllFunctions(), is(expectedFunctions));
-    }
-    
-    @Test
-    public void testThatTheRegistryUpdateWorksWithNullCollections() {
-        FunctionRegistry registry = new SimpleFunctionRegistry();
-        FunctionProvider provider = new RegistryFunctionProvider(registry);
-        OpenClassesWithFunctionsProvider classesWithFunctionsProvider = new OpenClassesWithFunctionsProvider();
-        DataMiningServer server = new DataMiningServerImpl(TestsUtil.getTestStringMessages(), registry, provider, classesWithFunctionsProvider);
-        
-        classesWithFunctionsProvider.internalClassesWithMarkedMethods = null;
-        classesWithFunctionsProvider.externalLibraryClasses = null;
-        server.getFunctionRegistry();
-    }
-
-    private class OpenClassesWithFunctionsProvider implements ClassesWithFunctionsProvider {
-
-        public Set<Class<?>> internalClassesWithMarkedMethods;
-        public Set<Class<?>> externalLibraryClasses;
-        
-        public OpenClassesWithFunctionsProvider() {
-            internalClassesWithMarkedMethods = new HashSet<>();
-            externalLibraryClasses = new HashSet<>();
-        }
-
-        @Override
-        public Set<Class<?>> getInternalClassesWithMarkedMethods() {
-            return internalClassesWithMarkedMethods;
-        }
-
-        @Override
-        public Set<Class<?>> getExternalLibraryClasses() {
-            return externalLibraryClasses;
-        }
-        
-    }
-    
-}

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

@@ -0,0 +1,209 @@
+package com.sap.sse.datamining.impl;
+
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.not;
+import static org.junit.Assert.assertThat;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.sap.sse.datamining.DataRetrieverChainBuilder;
+import com.sap.sse.datamining.DataRetrieverChainDefinition;
+import com.sap.sse.datamining.components.FilterCriterion;
+import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.criterias.AbstractFilterCriterion;
+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_HasRaceContext;
+import com.sap.sse.datamining.test.util.ComponentTestsUtil;
+import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
+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 TestDataRetrieverChainCreation {
+
+    private DataRetrieverChainDefinition<Collection<Test_Regatta>> dataRetrieverChainDefinition;
+    
+    private FilterCriterion<Test_HasRaceContext> raceFilter;
+    private FilterCriterion<Test_HasLegOfCompetitorContext> legOfCompetitorFilter;
+    
+    private int receivedLegOfCompetitorAmount = 0;
+    private Processor<Test_HasLegOfCompetitorContext, Void> legReceiver = new NullProcessor<Test_HasLegOfCompetitorContext, Void>(Test_HasLegOfCompetitorContext.class, Void.class) {
+        @Override
+        public void processElement(Test_HasLegOfCompetitorContext element) {
+            receivedLegOfCompetitorAmount++;
+        }
+    };
+
+    @SuppressWarnings("unchecked")
+    @Before
+    public void initializeRetrieverChain() {
+        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);
+    }
+    
+    @Before
+    public void initializeFilters() {
+        raceFilter = new AbstractFilterCriterion<Test_HasRaceContext>(Test_HasRaceContext.class) {
+            @Override
+            public boolean matches(Test_HasRaceContext element) {
+                return element.getBoatClass().getName().equals("49er");
+            }
+        };
+        
+        legOfCompetitorFilter = new AbstractFilterCriterion<Test_HasLegOfCompetitorContext>(Test_HasLegOfCompetitorContext.class) {
+            @Override
+            public boolean matches(Test_HasLegOfCompetitorContext element) {
+                return element.getLegNumber() <= 3;
+            }
+        };
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testCreationWithExistingChainDefinition() {
+        DataRetrieverChainDefinition<Collection<Test_Regatta>> chainClone = new SimpleDataRetrieverChainDefinition<>(dataRetrieverChainDefinition, "TestRetrieverChain");
+        assertThat(chainClone.getDataSourceType().equals(dataRetrieverChainDefinition.getDataSourceType()), is(true));
+        assertThat(chainClone.getRetrievedDataType().equals(dataRetrieverChainDefinition.getRetrievedDataType()), is(true));
+        
+        List<DataRetrieverTypeWithInformation<?, ?>> cloneDataRetrieverTypesWithInformation = (List<DataRetrieverTypeWithInformation<?, ?>>) chainClone.getDataRetrieverTypesWithInformation();
+        assertThat(cloneDataRetrieverTypesWithInformation, is(dataRetrieverChainDefinition.getDataRetrieverTypesWithInformation()));
+        
+        assertThat(chainClone.getUUID(), not(dataRetrieverChainDefinition.getUUID()));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testGetRetrievedDataTypeAndGetDataSourceType() {
+        DataRetrieverChainDefinition<Collection<Test_Regatta>> dataRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>((Class<Collection<Test_Regatta>>)(Class<?>) Collection.class, "TestRetrieverChain");
+        assertThat(dataRetrieverChainDefinition.getDataSourceType().equals(Collection.class), is(true));
+        
+        Class<Processor<Collection<Test_Regatta>, Test_Regatta>> regattaRetrieverClass = (Class<Processor<Collection<Test_Regatta>, Test_Regatta>>)(Class<?>) TestRegattaRetrievalProcessor.class;
+        dataRetrieverChainDefinition.startWith(regattaRetrieverClass, Test_Regatta.class);
+        assertThat(dataRetrieverChainDefinition.getRetrievedDataType().equals(Test_Regatta.class), is(true));
+        
+        Class<Processor<Test_Regatta, Test_HasRaceContext>> raceRetrieverClass = 
+                (Class<Processor<Test_Regatta, Test_HasRaceContext>>)(Class<?>) TestRaceWithContextRetrievalProcessor.class;
+        dataRetrieverChainDefinition.addAsLast(regattaRetrieverClass,
+                                               raceRetrieverClass,
+                                               Test_HasRaceContext.class);
+        assertThat(dataRetrieverChainDefinition.getRetrievedDataType().equals(Test_HasRaceContext.class), is(true));
+        
+        Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>> legRetrieverClass = 
+                (Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>>)(Class<?>) TestLegOfCompetitorWithContextRetrievalProcessor.class;
+        dataRetrieverChainDefinition.addAsLast(raceRetrieverClass,
+                                               legRetrieverClass,
+                                               Test_HasLegOfCompetitorContext.class);
+        assertThat(dataRetrieverChainDefinition.getRetrievedDataType().equals(Test_HasLegOfCompetitorContext.class), is(true));
+    }
+
+    @Test
+    public void testStepByStepDataRetrieverChainCreation() throws InterruptedException {
+        DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor());
+        assertThat(chainBuilder.getCurrentRetrievedDataType().equals(Test_Regatta.class), is(true));
+        assertThat(chainBuilder.canStepDeeper(), is(true));
+        
+        chainBuilder.stepDeeper().setFilter(raceFilter);
+        assertThat(chainBuilder.getCurrentRetrievedDataType().equals(Test_HasRaceContext.class), is(true));
+        assertThat(chainBuilder.canStepDeeper(), is(true));
+        
+        chainBuilder.stepDeeper().setFilter(legOfCompetitorFilter).addResultReceiver(legReceiver);
+        assertThat(chainBuilder.getCurrentRetrievedDataType().equals(Test_HasLegOfCompetitorContext.class), is(true));
+        assertThat(chainBuilder.canStepDeeper(), is(false));
+        
+        Processor<Collection<Test_Regatta>, ?> firstRetrieverInChain = chainBuilder.build();
+        firstRetrieverInChain.processElement(ComponentTestsUtil.createExampleDataSource());
+        firstRetrieverInChain.finish();
+        ConcurrencyTestsUtil.sleepFor(100);
+        assertThat(receivedLegOfCompetitorAmount, is(greaterThan(0)));
+        assertThat(receivedLegOfCompetitorAmount, is(lessThanOrEqualTo(3 /*races*/ * 3 /*legs*/ * 4 /*competitors*/)));
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test(expected=UnsupportedOperationException.class)
+    public void testAddAsLastWithoutStarting() {
+        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;
+        Class<Processor<Test_Regatta, Test_HasRaceContext>> raceRetrieverClass = 
+                (Class<Processor<Test_Regatta, Test_HasRaceContext>>)(Class<?>) TestRaceWithContextRetrievalProcessor.class;
+        dataRetrieverChainDefinition.addAsLast(regattaRetrieverClass,
+                                               raceRetrieverClass,
+                                               Test_HasRaceContext.class);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test(expected=UnsupportedOperationException.class)
+    public void testStartingTwice() {
+        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);
+        dataRetrieverChainDefinition.startWith(regattaRetrieverClass, Test_Regatta.class);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test(expected=IllegalArgumentException.class)
+    public void testStartingWithProcessorWithoutUsableConstructor() {
+        DataRetrieverChainDefinition<Collection<Test_Regatta>> dataRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>((Class<Collection<Test_Regatta>>)(Class<?>) Collection.class, "TestRetrieverChain");
+        dataRetrieverChainDefinition.startWith((Class<Processor<Collection<Test_Regatta>, Test_Regatta>>)(Class<?>) Processor.class, Test_Regatta.class);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test(expected=IllegalArgumentException.class)
+    public void testAddingProcessorWithoutUsableConstructor() {
+        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);
+        
+        dataRetrieverChainDefinition.addAsLast(regattaRetrieverClass,
+                                               (Class<Processor<Test_Regatta, Test_HasRaceContext>>)(Class<?>) Processor.class,
+                                               Test_HasRaceContext.class);
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test(expected=IllegalArgumentException.class)
+    public void testAddingRetrieverThatDoesntMatch() {
+        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;
+        Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>> legRetrieverClass = 
+                (Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>>)(Class<?>) TestLegOfCompetitorWithContextRetrievalProcessor.class;
+        dataRetrieverChainDefinition.addAsLast(raceRetrieverClass,
+                                               legRetrieverClass,
+                                               Test_HasLegOfCompetitorContext.class);
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void testSettingAFilterWithWrongElementType() {
+        dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor()).setFilter(raceFilter);
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void testSettingAResultReceiverWithWrongInputType() {
+        dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor()).addResultReceiver(legReceiver);
+    }
+
+}

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

@@ -0,0 +1,108 @@
+package com.sap.sse.datamining.impl;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+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.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_HasRaceContext;
+import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContextImpl;
+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 TestDataRetrieverChainDefinitionRegistry {
+    
+    private DataRetrieverChainDefinition<Collection<Test_Regatta>> raceRetrieverChainDefinition;
+    private DataRetrieverChainDefinition<Collection<Test_Regatta>> legRetrieverChainDefinition;
+    private DataRetrieverChainDefinitionRegistry dataRetrieverChainDefinitionRegistry;
+
+    @SuppressWarnings("unchecked")
+    @Before
+    public void initializeRetrieverChainsAndRegistry() {
+        raceRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<>((Class<Collection<Test_Regatta>>)(Class<?>) Collection.class, "TestRaceRetrieverChain");
+        Class<Processor<Collection<Test_Regatta>, Test_Regatta>> regattaRetrieverClass = (Class<Processor<Collection<Test_Regatta>, Test_Regatta>>)(Class<?>) TestRegattaRetrievalProcessor.class;
+        raceRetrieverChainDefinition.startWith(regattaRetrieverClass, Test_Regatta.class);
+        
+        Class<Processor<Test_Regatta, Test_HasRaceContext>> raceRetrieverClass = 
+                (Class<Processor<Test_Regatta, Test_HasRaceContext>>)(Class<?>) TestRaceWithContextRetrievalProcessor.class;
+        raceRetrieverChainDefinition.addAsLast(regattaRetrieverClass,
+                                               raceRetrieverClass,
+                                               Test_HasRaceContext.class);
+
+        legRetrieverChainDefinition = new SimpleDataRetrieverChainDefinition<Collection<Test_Regatta>>(raceRetrieverChainDefinition, "TestLegRetrieverChain");
+        
+        Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>> legRetrieverClass = 
+                (Class<Processor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>>)(Class<?>) TestLegOfCompetitorWithContextRetrievalProcessor.class;
+        legRetrieverChainDefinition.addAsLast(raceRetrieverClass,
+                                               legRetrieverClass,
+                                               Test_HasLegOfCompetitorContext.class);
+        
+        dataRetrieverChainDefinitionRegistry = new SimpleDataRetrieverChainDefinitionRegistry();
+        dataRetrieverChainDefinitionRegistry.add(raceRetrieverChainDefinition);
+        dataRetrieverChainDefinitionRegistry.add(legRetrieverChainDefinition);
+        
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testGetDataRetrieverChainDefinitions() {
+        Class<Collection<Test_Regatta>> dataSourceType = (Class<Collection<Test_Regatta>>)(Class<?>) Collection.class;
+        
+        Collection<DataRetrieverChainDefinition<Collection<Test_Regatta>>> expectedDataRetrieverChainDefinitions = new HashSet<>();
+        expectedDataRetrieverChainDefinitions.add(raceRetrieverChainDefinition);
+        assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(dataSourceType, Test_HasRaceContext.class), is(expectedDataRetrieverChainDefinitions));
+        
+        expectedDataRetrieverChainDefinitions = new HashSet<>();
+        expectedDataRetrieverChainDefinitions.add(legRetrieverChainDefinition);
+        assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinitions(dataSourceType, Test_HasLegOfCompetitorContext.class), is(expectedDataRetrieverChainDefinitions));
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testSingleGetDataRetrieverChainDefinition() {
+        Class<Collection<Test_Regatta>> dataSourceType = (Class<Collection<Test_Regatta>>)(Class<?>) Collection.class;
+        
+        assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinition(dataSourceType, raceRetrieverChainDefinition.getUUID()),
+                is(raceRetrieverChainDefinition));
+        
+        assertThat(dataRetrieverChainDefinitionRegistry.getDataRetrieverChainDefinition(dataSourceType, legRetrieverChainDefinition.getUUID()),
+                is(legRetrieverChainDefinition));
+    }
+    
+    @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 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.test/src/com/sap/sse/datamining/impl/TestDimensionsValuesQuery.java

@@ -6,6 +6,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
@@ -13,41 +14,38 @@ import java.util.concurrent.ExecutionException;
 import org.junit.Before;
 import org.junit.Test;
 
+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.factories.FunctionDTOFactory;
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
-import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
+import com.sap.sse.datamining.i18n.DataMiningStringMessages;
 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.aggregators.ParallelGroupedDataCollectingAsSetProcessor;
 import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Boat;
-import com.sap.sse.datamining.test.functions.registry.test_classes.Test_BoatClass;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Competitor;
-import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Leg;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Named;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Race;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Regatta;
-import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Team;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_BoatClassImpl;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_BoatImpl;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_CompetitorImpl;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_LegImpl;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_RaceImpl;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_RegattaImpl;
-import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_TeamImpl;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegContext;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegContextImpl;
+import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegOfCompetitorContext;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContext;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContextImpl;
+import com.sap.sse.datamining.test.util.ComponentTestsUtil;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+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 TestDimensionsValuesQuery {
+
+    private static final DataMiningStringMessages stringMessages = TestsUtil.getTestStringMessagesWithProductiveMessages();
+    private static final Locale locale = Locale.ENGLISH;
+    
+    private DataRetrieverChainDefinition<Collection<Test_Regatta>> dataRetrieverChainDefinition;
+    private Collection<Test_Regatta> dataSource;
     
     //Test_HasRaceContext dimensions
     private Function<String> dimensionRegattaName;
@@ -59,8 +57,6 @@ public class TestDimensionsValuesQuery {
     private Function<Integer> dimensionLegNumber;
     private Function<String> dimensionCompetitorName;
     private Function<String> dimensionCompetitorSailID;
-    
-    private Collection<Test_Regatta> dataSource;
 
     @Test
     public void testDimensionsValuesQuery() throws InterruptedException, ExecutionException {
@@ -72,89 +68,55 @@ public class TestDimensionsValuesQuery {
     private Query<Set<Object>> createDimensionsValuesQuery() {
         return new ProcessorQuery<Set<Object>, Collection<Test_Regatta>>(ConcurrencyTestsUtil.getExecutor(), dataSource) {
             @Override
-            protected Processor<Collection<Test_Regatta>> createFirstProcessor() {
-                Collection<Processor<Map<GroupKey, Set<Object>>>> collectorResultReceivers = Arrays.asList(/*query*/ this.getResultReceiver());
-                
-                Processor<GroupedDataEntry<Object>> resultCollector = new ParallelGroupedDataCollectingAsSetProcessor<Object>(ConcurrencyTestsUtil.getExecutor(), collectorResultReceivers);
-                Collection<Processor<GroupedDataEntry<Object>>> extractionResultReceivers = new ArrayList<>();
-                extractionResultReceivers.add(resultCollector);
+            protected Processor<Collection<Test_Regatta>, ?> createFirstProcessor() {
+                Processor<GroupedDataEntry<Object>, Map<GroupKey, Set<Object>>> resultCollector = ComponentTestsUtil.getProcessorFactory().createGroupedDataCollectingAsSetProcessor(this); 
                 
                 Collection<Function<?>> legDimensions = new ArrayList<>();
                 legDimensions.add(dimensionLegNumber);
                 legDimensions.add(dimensionCompetitorName);
                 legDimensions.add(dimensionCompetitorSailID);
-                Collection<Processor<Test_HasLegContext>> legRetrieverResultReceivers = createGroupingExtractorsForDimensions(extractionResultReceivers, legDimensions);
-                Processor<Test_HasRaceContext> legRetriever = new AbstractSimpleRetrievalProcessor<Test_HasRaceContext, Test_HasLegContext>(ConcurrencyTestsUtil.getExecutor(), legRetrieverResultReceivers) {
-                    @Override
-                    protected Iterable<Test_HasLegContext> retrieveData(Test_HasRaceContext raceWithContext) {
-                        Collection<Test_HasLegContext> legsWithContext = new ArrayList<>();
-                        int legNumber = 0;
-                        for (Test_Leg leg : raceWithContext.getRace().getLegs()) {
-                            legNumber++;
-                            for (Test_Competitor competitor : raceWithContext.getRace().getCompetitors()) {
-                                legsWithContext.add(new Test_HasLegContextImpl(raceWithContext.getRegatta(), raceWithContext.getRace(), raceWithContext.getBoatClass(),
-                                                                               raceWithContext.getYear(), leg, legNumber, competitor));
-                            }
-                        }
-                        return legsWithContext;
-                    }
-                };
-
                 
                 Collection<Function<?>> raceDimensions = new ArrayList<>();
                 raceDimensions.add(dimensionRegattaName);
                 raceDimensions.add(dimensionRaceName);
                 raceDimensions.add(dimensionBoatClassName);
                 raceDimensions.add(dimensionYear);
-                Collection<Processor<Test_HasRaceContext>> raceRetrieverResultReceivers = createGroupingExtractorsForDimensions(extractionResultReceivers, raceDimensions);
-                raceRetrieverResultReceivers.add(legRetriever);
-                return new AbstractSimpleRetrievalProcessor<Collection<Test_Regatta>, Test_HasRaceContext>(ConcurrencyTestsUtil.getExecutor(), raceRetrieverResultReceivers) {
-                    @Override
-                    protected Iterable<Test_HasRaceContext> retrieveData(Collection<Test_Regatta> regattas) {
-                        Collection<Test_HasRaceContext> racesWithContext = new ArrayList<>();
-                        for (Test_Regatta regatta : regattas) {
-                            for (Test_Race race : regatta.getRaces()) {
-                                racesWithContext.add(new Test_HasRaceContextImpl(regatta, race, regatta.getBoatClass(), regatta.getYear()));
-                            }
-                        }
-                        return racesWithContext;
-                    }
-                };
+                
+                DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor());
+                chainBuilder.stepDeeper();
+                for (Processor<?, ?> resultReceiver : ComponentTestsUtil.getProcessorFactory().createGroupingExtractorsForDimensions(Test_HasRaceContext.class, resultCollector, raceDimensions, stringMessages, locale)) {
+                    chainBuilder.addResultReceiver(resultReceiver);
+                }
+                
+                chainBuilder.stepDeeper();
+                for (Processor<?, ?> resultReceiver : ComponentTestsUtil.getProcessorFactory().createGroupingExtractorsForDimensions(Test_HasLegOfCompetitorContext.class, resultCollector, legDimensions, stringMessages, locale)) {
+                    chainBuilder.addResultReceiver(resultReceiver);
+                }
+                
+                return chainBuilder.build();
             }
         };
     }
-
-    @SuppressWarnings("unchecked")
-    private <DataType> Collection<Processor<DataType>> createGroupingExtractorsForDimensions(
-            Collection<Processor<GroupedDataEntry<Object>>> extractionResultReceivers, Collection<Function<?>> dimensions) {
-        Collection<Processor<DataType>> groupingExtractors = new ArrayList<>();
-        for (Function<?> dimension : dimensions) {
-            Processor<GroupedDataEntry<DataType>> dimensionValueExtractor = new ParallelGroupedElementsValueExtractionProcessor<DataType, Object>(ConcurrencyTestsUtil.getExecutor(), extractionResultReceivers, (Function<Object>) dimension);
-            Processor<DataType> byDimensionGrouper = new ParallelByDimensionGroupingProcessor<>(ConcurrencyTestsUtil.getExecutor(), Arrays.asList(dimensionValueExtractor), dimension);
-            groupingExtractors.add(byDimensionGrouper);
-        }
-        return groupingExtractors;
-    }
     
     private Map<GroupKey, Set<Object>> buildExpectedResultData() {
         Map<GroupKey, Set<Object>> expectedResultData = new HashMap<>();
 
         //Add empty sets for Test_HasRaceContext dimensions
-        GroupKey dimensionRegattaNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionRegattaName));
+        GroupKey dimensionRegattaNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionRegattaName, stringMessages, locale));
         expectedResultData.put(dimensionRegattaNameGroupKey, new HashSet<Object>());
-        GroupKey dimensionRaceNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionRaceName));
+        GroupKey dimensionRaceNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionRaceName, stringMessages, locale));
         expectedResultData.put(dimensionRaceNameGroupKey, new HashSet<Object>());
-        GroupKey dimensionBoatClassNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionBoatClassName));
+        GroupKey dimensionBoatClassNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionBoatClassName, stringMessages, locale));
         expectedResultData.put(dimensionBoatClassNameGroupKey, new HashSet<Object>());
-        GroupKey dimensionYearGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionYear));
+        GroupKey dimensionYearGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionYear, stringMessages, locale));
         expectedResultData.put(dimensionYearGroupKey, new HashSet<Object>());
 
         //Add empty sets for Test_HasLegContext dimensions
-        GroupKey dimensionLegNumberGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionLegNumber));
+        GroupKey dimensionLegNumberGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionLegNumber, stringMessages, locale));
         expectedResultData.put(dimensionLegNumberGroupKey, new HashSet<Object>());
-        GroupKey dimensionCompetitorNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionCompetitorName));
+        GroupKey dimensionCompetitorNameGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionCompetitorName, stringMessages, locale));
         expectedResultData.put(dimensionCompetitorNameGroupKey, new HashSet<Object>());
-        GroupKey dimensionCompetitorSailIDGroupKey = new GenericGroupKey<FunctionDTO>(FunctionDTOFactory.createFunctionDTO(dimensionCompetitorSailID));
+        GroupKey dimensionCompetitorSailIDGroupKey = new GenericGroupKey<FunctionDTO>(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimensionCompetitorSailID, stringMessages, locale));
         expectedResultData.put(dimensionCompetitorSailIDGroupKey, new HashSet<Object>());
         
         for (Test_Regatta regatta : dataSource) {
@@ -177,101 +139,67 @@ public class TestDimensionsValuesQuery {
         }
         return expectedResultData;
     }
+    
+    @SuppressWarnings("unchecked")
+    @Before
+    public void initializeDataRetrieverChain() {
+        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);
+    }
 
     @Before
     public void initializeDimensions() throws NoSuchMethodException, SecurityException {
         Method getNameMethod = Test_Named.class.getMethod("getName", new Class<?>[0]);
-        Function<?> getName = FunctionFactory.createMethodWrappingFunction(getNameMethod);
+        Function<?> getName = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getNameMethod);
         
         Method getRegattaMethod = Test_HasRaceContext.class.getMethod("getRegatta", new Class<?>[0]);
-        Function<?> getRegatta = FunctionFactory.createMethodWrappingFunction(getRegattaMethod);
-        dimensionRegattaName = FunctionFactory.createCompoundFunction(null, Arrays.asList(getRegatta, getName));
+        Function<?> getRegatta = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getRegattaMethod);
+        dimensionRegattaName = FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getRegatta, getName));
 
         Method getRaceMethod = Test_HasRaceContext.class.getMethod("getRace", new Class<?>[0]);
-        Function<?> getRace = FunctionFactory.createMethodWrappingFunction(getRaceMethod);
-        dimensionRaceName = FunctionFactory.createCompoundFunction(null, Arrays.asList(getRace, getName));
+        Function<?> getRace = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getRaceMethod);
+        dimensionRaceName = FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getRace, getName));
         
         Method getBoatClassMethod = Test_HasRaceContext.class.getMethod("getBoatClass", new Class<?>[0]);
-        Function<?> getBoatClass = FunctionFactory.createMethodWrappingFunction(getBoatClassMethod);
-        dimensionBoatClassName = FunctionFactory.createCompoundFunction(null, Arrays.asList(getBoatClass, getName));
+        Function<?> getBoatClass = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getBoatClassMethod);
+        dimensionBoatClassName = FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getBoatClass, getName));
         
         Method getYearMethod = Test_HasRaceContext.class.getMethod("getYear", new Class<?>[0]);
-        dimensionYear = FunctionFactory.createMethodWrappingFunction(getYearMethod);
+        dimensionYear = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getYearMethod);
         
-        Method getLegNumberMethod = Test_HasLegContext.class.getMethod("getLegNumber", new Class<?>[0]);
-        dimensionLegNumber = FunctionFactory.createMethodWrappingFunction(getLegNumberMethod);
+        Method getLegNumberMethod = Test_HasLegOfCompetitorContext.class.getMethod("getLegNumber", new Class<?>[0]);
+        dimensionLegNumber = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getLegNumberMethod);
         
-        Method getCompetitorMethod = Test_HasLegContext.class.getMethod("getCompetitor", new Class<?>[0]);
-        Function<?> getCompetitor = FunctionFactory.createMethodWrappingFunction(getCompetitorMethod);
+        Method getCompetitorMethod = Test_HasLegOfCompetitorContext.class.getMethod("getCompetitor", new Class<?>[0]);
+        Function<?> getCompetitor = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getCompetitorMethod);
         
         Method getTeamMethod = Test_Competitor.class.getMethod("getTeam", new Class<?>[0]);
-        Function<?> getTeam = FunctionFactory.createMethodWrappingFunction(getTeamMethod);
-        dimensionCompetitorName = FunctionFactory.createCompoundFunction(null, Arrays.asList(getCompetitor, getTeam, getName));
+        Function<?> getTeam = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getTeamMethod);
+        dimensionCompetitorName = FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getCompetitor, getTeam, getName));
         
         Method getBoatMethod = Test_Competitor.class.getMethod("getBoat", new Class<?>[0]);
-        Function<?> getBoat = FunctionFactory.createMethodWrappingFunction(getBoatMethod);
+        Function<?> getBoat = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getBoatMethod);
         Method getSailIDMethod = Test_Boat.class.getMethod("getSailID", new Class<?>[0]);
-        Function<?> getSailID = FunctionFactory.createMethodWrappingFunction(getSailIDMethod);
-        dimensionCompetitorSailID = FunctionFactory.createCompoundFunction(null, Arrays.asList(getCompetitor, getBoat, getSailID));
+        Function<?> getSailID = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getSailIDMethod);
+        dimensionCompetitorSailID = FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getCompetitor, getBoat, getSailID));
     }
     
     @Before
     public void initializeDataSource() {
-        //Initialize 49er competitors
-        Test_Team team1_49er = new Test_TeamImpl("49er Team 1");
-        Test_Boat boatGER1 = new Test_BoatImpl("GER1");
-        Test_Competitor competitor1_49er = new Test_CompetitorImpl(team1_49er, boatGER1);
-        
-        Test_Team team2_49er = new Test_TeamImpl("49er Team 2");
-        Test_Boat boatGER2 = new Test_BoatImpl("GER2");
-        Test_Competitor competitor2_49er = new Test_CompetitorImpl(team2_49er, boatGER2);
-        
-        Test_Team team3_49er = new Test_TeamImpl("49er Team 3");
-        Test_Boat boatGER3 = new Test_BoatImpl("GER3");
-        Test_Competitor competitor3_49er = new Test_CompetitorImpl(team3_49er, boatGER3);
-        
-        Test_Team team4_49er = new Test_TeamImpl("49er Team 4");
-        Test_Boat boatGER4 = new Test_BoatImpl("GER4");
-        Test_Competitor competitor4_49er = new Test_CompetitorImpl(team4_49er, boatGER4);
-        
-        Collection<Test_Competitor> competitors49er = Arrays.asList(competitor1_49er, competitor2_49er, competitor3_49er, competitor4_49er);
-
-        //Initialize 505 competitors
-        Test_Team team1_505 = new Test_TeamImpl("505 Team 1");
-        Test_Boat boatENG1 = new Test_BoatImpl("ENG1");
-        Test_Competitor competitor1_505 = new Test_CompetitorImpl(team1_505, boatENG1);
-        
-        Test_Team team2_505 = new Test_TeamImpl("505 Team 2");
-        Test_Boat boatENG2 = new Test_BoatImpl("ENG2");
-        Test_Competitor competitor2_505 = new Test_CompetitorImpl(team2_505, boatENG2);
-        
-        Test_Team team3_505 = new Test_TeamImpl("505 Team 3");
-        Test_Boat boatENG3 = new Test_BoatImpl("ENG3");
-        Test_Competitor competitor3_505 = new Test_CompetitorImpl(team3_505, boatENG3);
-        
-        Collection<Test_Competitor> competitors505 = Arrays.asList(competitor1_505, competitor2_505, competitor3_505);
-        
-        // Test_Leg has only the statistic distance traveled
-        // This test requires only the dimensions, so only one leg is necessary
-        Test_Leg leg = new Test_LegImpl(0.0);
-        Collection<Test_Leg> legs = Arrays.asList(leg, leg, leg, leg, leg);
-        
-        //Initialize races, boat classes and regattas
-        Test_Race race1_49er = new Test_RaceImpl("Race 1", competitors49er, legs);
-        Test_Race race2_49er = new Test_RaceImpl("Race 2", competitors49er, legs);
-        Test_Race race3_49er = new Test_RaceImpl("Race 3", competitors49er, legs);
-        Test_Race race1_505 = new Test_RaceImpl("Race 1", competitors505, legs);
-        Test_Race race2_505 = new Test_RaceImpl("Race 2", competitors505, legs);
-
-        Test_BoatClass boatClass49er = new Test_BoatClassImpl("49er");
-        Test_BoatClass boatClass505 = new Test_BoatClassImpl("505");
-        
-        Test_Regatta regatta49er = new Test_RegattaImpl("KW 2014 49er", boatClass49er, 2014, race1_49er, race2_49er, race3_49er);
-        Test_Regatta regatta505 = new Test_RegattaImpl("KW 2014 505", boatClass505, 2014, race1_505, race2_505);
-        
-        dataSource = new ArrayList<>();
-        dataSource.add(regatta49er);
-        dataSource.add(regatta505);
+        dataSource = ComponentTestsUtil.createExampleDataSource();
     }
 
 }

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

@@ -6,9 +6,9 @@ import static org.junit.Assert.fail;
 
 import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.Callable;
@@ -17,39 +17,48 @@ import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
+import org.junit.Before;
 import org.junit.Test;
 
 import com.sap.sse.datamining.AdditionalResultDataBuilder;
 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.i18n.DataMiningStringMessages;
-import com.sap.sse.datamining.impl.components.AbstractSimpleFilteringRetrievalProcessor;
 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.ParallelGroupedElementsValueExtractionProcessor;
-import com.sap.sse.datamining.impl.components.ParallelMultiDimensionsValueNestingGroupingProcessor;
-import com.sap.sse.datamining.impl.components.aggregators.ParallelGroupedDoubleDataSumAggregationProcessor;
+import com.sap.sse.datamining.impl.components.ParallelFilteringProcessor;
+import com.sap.sse.datamining.impl.criterias.AbstractFilterCriterion;
 import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.QueryResult;
 import com.sap.sse.datamining.shared.Unit;
+import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.impl.AdditionalResultDataImpl;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
 import com.sap.sse.datamining.shared.impl.QueryResultImpl;
-import com.sap.sse.datamining.test.components.util.BlockingProcessor;
-import com.sap.sse.datamining.test.components.util.Number;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
 import com.sap.sse.datamining.test.util.FunctionTestsUtil;
 import com.sap.sse.datamining.test.util.TestsUtil;
+import com.sap.sse.datamining.test.util.components.BlockingProcessor;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
+import com.sap.sse.datamining.test.util.components.Number;
 
 public class TestProcessorQuery {
     
     private final static DataMiningStringMessages stringMessages = TestsUtil.getTestStringMessagesWithProductiveMessages();
+    
+    private static ProcessorFactory processorFactory;
 
     private boolean receivedElementOrFinished;
     private boolean receivedAbort;
+    
+    @Before
+    public void initializeProcessorFactory() {
+        processorFactory = new ProcessorFactory(ConcurrencyTestsUtil.getExecutor());
+    }
 
     @Test
     public void testStandardWorkflow() throws InterruptedException, ExecutionException {
@@ -99,38 +108,42 @@ public class TestProcessorQuery {
      */
     private Query<Double> createQueryWithStandardWorkflow(Collection<Number> dataSource) {
         final ThreadPoolExecutor executor = ConcurrencyTestsUtil.getExecutor();
-        ProcessorQuery<Double, Iterable<Number>> query = new ProcessorQuery<Double, Iterable<Number>>(executor,
-                dataSource, stringMessages, Locale.ENGLISH) {
+        ProcessorQuery<Double, Iterable<Number>> query = new ProcessorQuery<Double, Iterable<Number>>(executor, dataSource, stringMessages, Locale.ENGLISH) {
             @Override
-            protected Processor<Iterable<Number>> createFirstProcessor() {
-                Collection<Processor<Map<GroupKey, Double>>> aggregationResultReceivers = Arrays.asList(/*query*/ this.getResultReceiver());
-                Processor<GroupedDataEntry<Double>> sumAggregator =
-                        new ParallelGroupedDoubleDataSumAggregationProcessor(executor, aggregationResultReceivers);
+            protected Processor<Iterable<Number>, ?> createFirstProcessor() {
+                Processor<GroupedDataEntry<Double>, Map<GroupKey, Double>> sumAggregator = processorFactory.createAggregationProcessor(this, AggregatorType.Sum);
                 
                 Method getCrossSumMethod = FunctionTestsUtil.getMethodFromClass(Number.class, "getCrossSum");
-                Function<Double> getCrossSumFunction = FunctionFactory.createMethodWrappingFunction(getCrossSumMethod);
-                Processor<GroupedDataEntry<Number>> crossSumExtractor = new ParallelGroupedElementsValueExtractionProcessor<Number, Double>(
-                        executor, Arrays.asList(sumAggregator), getCrossSumFunction);
+                Function<Double> getCrossSumFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getCrossSumMethod);
+                Processor<GroupedDataEntry<Number>, GroupedDataEntry<Double>> crossSumExtractor = processorFactory.createExtractionProcessor(sumAggregator, getCrossSumFunction);
 
-                Collection<Function<?>> dimensions = new ArrayList<>();
-                Function<Integer> getLengthFunction = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(Number.class, "getLength"));
+                List<Function<?>> dimensions = new ArrayList<>();
+                Function<Integer> getLengthFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(Number.class, "getLength"));
                 dimensions.add(getLengthFunction);
-                Processor<Number> lengthGrouper = new ParallelMultiDimensionsValueNestingGroupingProcessor<>(executor, Arrays.asList(crossSumExtractor), dimensions);
+                Processor<Number, GroupedDataEntry<Number>> lengthGrouper = processorFactory.createGroupingProcessor(Number.class, crossSumExtractor, dimensions);
+                Collection<Processor<Number, ?>> filtrationResultReceivers = new ArrayList<>();
+                filtrationResultReceivers.add(lengthGrouper);
                 
-                FilterCriterion<Number> retrievalFilterCriteria = new FilterCriterion<Number>() {
+                FilterCriterion<Number> filterCriterion = new AbstractFilterCriterion<Number>(Number.class) {
                     @Override
                     public boolean matches(Number element) {
                         return element.getValue() >= 10;
                     }
                 };
-                Processor<Iterable<Number>> filteringRetrievalProcessor = new AbstractSimpleFilteringRetrievalProcessor<Iterable<Number>, Number>(ConcurrencyTestsUtil.getExecutor(), Arrays.asList(lengthGrouper), retrievalFilterCriteria) {
+                Processor<Number, Number> filtrationProcessor =  new ParallelFilteringProcessor<>(Number.class, executor, filtrationResultReceivers, filterCriterion);
+                Collection<Processor<Number, ?>> retrievalResultReceivers = new ArrayList<>();
+                retrievalResultReceivers.add(filtrationProcessor);
+                
+                @SuppressWarnings("unchecked")
+                Processor<Iterable<Number>, Number> retrievalProcessor = new AbstractSimpleRetrievalProcessor<Iterable<Number>, Number>((Class<Iterable<Number>>)(Class<?>) Iterable.class, Number.class,
+                                                                                                                                                          ConcurrencyTestsUtil.getExecutor(), retrievalResultReceivers) {
                     @Override
                     protected Iterable<Number> retrieveData(Iterable<Number> element) {
                         return element;
                     }
                 };
                 
-                return filteringRetrievalProcessor;
+                return retrievalProcessor;
             }
         };
         return query;
@@ -158,17 +171,15 @@ public class TestProcessorQuery {
     public void testQueryTimeouting() throws TimeoutException {
         ProcessorQuery<Double, Iterable<Number>> query = new ProcessorQuery<Double, Iterable<Number>>(
                 ConcurrencyTestsUtil.getExecutor(), createDataSource(), stringMessages, Locale.ENGLISH) {
+            @SuppressWarnings("unchecked")
             @Override
-            protected Processor<Iterable<Number>> createFirstProcessor() {
-                Processor<Double> resultReceiver = new Processor<Double>() {
+            protected Processor<Iterable<Number>, ?> createFirstProcessor() {
+                Processor<Double, Void> resultReceiver = new NullProcessor<Double, Void>(Double.class, Void.class) {
                     @Override
                     public void processElement(Double element) {
                         receivedElementOrFinished = true;
                     }
                     @Override
-                    public void onFailure(Throwable failure) {
-                    }
-                    @Override
                     public void finish() throws InterruptedException {
                         receivedElementOrFinished = true;
                     }
@@ -176,12 +187,10 @@ public class TestProcessorQuery {
                     public void abort() {
                         receivedAbort = true;
                     }
-                    @Override
-                    public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                        return additionalDataBuilder;
-                    }
                 };
-                return new BlockingProcessor<Iterable<Number>, Double>(ConcurrencyTestsUtil.getExecutor(), Arrays.asList(resultReceiver), (long) 1000);
+                Collection<Processor<Double, ?>> resultReceivers = new ArrayList<>();
+                resultReceivers.add(resultReceiver);
+                return new BlockingProcessor<Iterable<Number>, Double>((Class<Iterable<Number>>)(Class<?>) Iterable.class, Double.class, ConcurrencyTestsUtil.getExecutor(), resultReceivers, (long) 1000);
             }
         };
         
@@ -203,7 +212,7 @@ public class TestProcessorQuery {
         ProcessorQuery<Double, Iterable<Number>> query = new ProcessorQuery<Double, Iterable<Number>>(
                 ConcurrencyTestsUtil.getExecutor(), createDataSource(), stringMessages, Locale.ENGLISH) {
             @Override
-            protected Processor<Iterable<Number>> createFirstProcessor() {
+            protected Processor<Iterable<Number>, ?> createFirstProcessor() {
                 return createSumBuildingProcessor(/*query*/ this, keyValue);
             }
         };
@@ -213,10 +222,15 @@ public class TestProcessorQuery {
         assertThat(query.run(500, TimeUnit.MILLISECONDS).getResults(), is(expectedResult));
     }
 
+    @SuppressWarnings("unchecked")
     private AbstractSimpleParallelProcessor<Iterable<Number>, Map<GroupKey, Double>> createSumBuildingProcessor(
             ProcessorQuery<Double, Iterable<Number>> query, final String keyValue) {
-        return new AbstractSimpleParallelProcessor<Iterable<Number>, Map<GroupKey, Double>>(ConcurrencyTestsUtil.getExecutor(),
-                                                                                            Arrays.asList(query.getResultReceiver())) {
+        Collection<Processor<Map<GroupKey, Double>, ?>> resultReceivers = new ArrayList<>();
+        resultReceivers.add(query.getResultReceiver());
+        return new AbstractSimpleParallelProcessor<Iterable<Number>, Map<GroupKey, Double>>((Class<Iterable<Number>>)(Class<?>) Iterable.class,
+                                                                                            (Class<Map<GroupKey, Double>>)(Class<?>) Map.class,
+                                                                                            ConcurrencyTestsUtil.getExecutor(),
+                                                                                            resultReceivers) {
             @Override
             protected Callable<Map<GroupKey, Double>> createInstruction(final Iterable<Number> element) {
                 return new Callable<Map<GroupKey,Double>>() {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestAbstractParallelProcessorFinishing.java

@@ -14,11 +14,12 @@ import org.junit.Test;
 import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
 public class TestAbstractParallelProcessorFinishing {
     
-    private Processor<Integer> processor;
-    private Processor<Integer> receiver;
+    private Processor<Integer, Integer> processor;
+    private Processor<Integer, ?> receiver;
     
     private boolean instructionIsWorking;
     private boolean receiverWasToldToFinish;
@@ -30,7 +31,7 @@ public class TestAbstractParallelProcessorFinishing {
         
         receiver = createReceiver();
         
-        Collection<Processor<Integer>> receivers = new HashSet<>();
+        Collection<Processor<Integer, ?>> receivers = new HashSet<>();
         receivers.add(receiver);
         processor = createProcessor(receivers);
     }
@@ -47,27 +48,21 @@ public class TestAbstractParallelProcessorFinishing {
         
     }
 
-    private Processor<Integer> createReceiver() {
-        return new Processor<Integer>() {
-            @Override
-            public void processElement(Integer element) { }
-            @Override
-            public void onFailure(Throwable failure) { }
+    private Processor<Integer, ?> createReceiver() {
+        return new NullProcessor<Integer, Void>(Integer.class, Void.class) {
             @Override
             public void finish() throws InterruptedException {
                 receiverWasToldToFinish = true;
             }
             @Override
-            public void abort() { }
-            @Override
             public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
                 return additionalDataBuilder;
             }
         };
     }
 
-    private AbstractSimpleParallelProcessor<Integer, Integer> createProcessor(Collection<Processor<Integer>> receivers) {
-        return new AbstractSimpleParallelProcessor<Integer, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers) {
+    private AbstractSimpleParallelProcessor<Integer, Integer> createProcessor(Collection<Processor<Integer, ?>> receivers) {
+        return new AbstractSimpleParallelProcessor<Integer, Integer>(Integer.class, Integer.class, ConcurrencyTestsUtil.getExecutor(), receivers) {
             @Override
             protected Callable<Integer> createInstruction(Integer partialElement) {
                 return new Callable<Integer>() {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestAbstractParallelProcessorWithManySimpleInstructions.java

@@ -13,40 +13,31 @@ import org.junit.Test;
 import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
 public class TestAbstractParallelProcessorWithManySimpleInstructions {
     
-    private Processor<Integer> processor;
+    private Processor<Integer, Integer> processor;
     
     private int sum = 0;
     private boolean receiverWasToldToFinish = false;
     
     @Before
     public void initializeProcessor() {
-        Processor<Integer> receiver = new Processor<Integer>() {
+        Processor<Integer, Void> receiver = new NullProcessor<Integer, Void>(Integer.class, Void.class) {
             @Override
             public void processElement(Integer element) {
                 incrementSum(element);
             }
             @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
             public void finish() throws InterruptedException {
                 receiverWasToldToFinish = true;
             }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
-        Collection<Processor<Integer>> receivers = new ArrayList<>();
+        Collection<Processor<Integer, ?>> receivers = new ArrayList<>();
         receivers.add(receiver);
-        processor = new AbstractSimpleParallelProcessor<Integer, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers) {
+        processor = new AbstractSimpleParallelProcessor<Integer, Integer>(Integer.class, Integer.class, ConcurrencyTestsUtil.getExecutor(), receivers) {
             @Override
             protected Callable<Integer> createInstruction(final Integer element) {
                 return new Callable<Integer>() {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestAbstractProcessor.java

@@ -1,64 +0,0 @@
-package com.sap.sse.datamining.impl.components;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-
-import java.util.Collection;
-import java.util.HashSet;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
-import com.sap.sse.datamining.components.Processor;
-
-public class TestAbstractProcessor {
-    
-    private Collection<Processor<Integer>> receivers;
-    private boolean receiverWasToldToFinish;
-    
-    @Before
-    public void initializeReceivers() {
-        Processor<Integer> receiver = new Processor<Integer>() {
-            @Override
-            public void processElement(Integer element) {
-            }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-                receiverWasToldToFinish = true;
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
-        };
-        
-        receivers = new HashSet<>();
-        receivers.add(receiver);
-    }
-
-    @Test
-    public void testFinishing() throws InterruptedException {
-        Processor<Integer> processor = new AbstractProcessor<Integer, Integer>(receivers) {
-            @Override
-            protected Integer handleElement(Integer element) {
-                return null;
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            protected void setAdditionalData(AdditionalResultDataBuilder additionalDataBuilder) {
-            }
-        };
-        processor.finish();
-        assertThat(receiverWasToldToFinish, is(true));
-    }
-
-}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestFilteringProcessors.java

@@ -12,14 +12,15 @@ import java.util.Map;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.criterias.AbstractFilterCriterion;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
 public class TestFilteringProcessors {
     
-    private Collection<Processor<Integer>> receivers;
+    private Collection<Processor<Integer, ?>> receivers;
     /**
      * Contains the last received elements as key and the amount of the received times as value;
      */
@@ -27,14 +28,14 @@ public class TestFilteringProcessors {
 
     @Test
     public void testFilteringProcessor() {
-        FilterCriterion<Integer> elementIsEvenCriteria = new FilterCriterion<Integer>() {
+        FilterCriterion<Integer> elementIsEvenCriteria = new AbstractFilterCriterion<Integer>(Integer.class) {
             @Override
             public boolean matches(Integer element) {
                 return element % 2 == 0;
             }
         };
-        Processor<Integer> filteringProcessor = new ParallelFilteringProcessor<Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, elementIsEvenCriteria);
-        processElements(filteringProcessor, createElementsToProcess());
+        Processor<Integer, Integer> filteringProcessor = new ParallelFilteringProcessor<Integer>(Integer.class, ConcurrencyTestsUtil.getExecutor(), receivers, elementIsEvenCriteria);
+        ConcurrencyTestsUtil.processElements(filteringProcessor, createElementsToProcess());
         ConcurrencyTestsUtil.sleepFor(100); // Giving the processor time to process the instructions
         
         Collection<Integer> evenElements = new ArrayList<>();
@@ -54,19 +55,6 @@ public class TestFilteringProcessors {
         }
     }
 
-    @Test
-    public void testNonFilteringProcessorFiltration() {
-        Processor<Integer> nonFilteringProcessor = new NonFilteringProcessor<Integer>(receivers);
-        processElements(nonFilteringProcessor, createElementsToProcess());
-        verifyThatExpectedElementsHasBeenReceived(createElementsToProcess());
-    }
-
-    private void processElements(Processor<Integer> processor, Collection<Integer> elements) {
-        for (Integer element : elements) {
-            processor.processElement(element);
-        }
-    }
-
     private Collection<Integer> createElementsToProcess() {
         Collection<Integer> elements = new ArrayList<>();
         elements.add(1);
@@ -86,7 +74,7 @@ public class TestFilteringProcessors {
     public void initializeReceivers() {
         receivedElements = new HashMap<>();
         
-        Processor<Integer> receiver = new Processor<Integer>() {
+        Processor<Integer, Void> receiver = new NullProcessor<Integer, Void>(Integer.class, Void.class) {
             @Override
             public void processElement(Integer element) {
                 if (!receivedElements.containsKey(element)) {
@@ -95,19 +83,6 @@ public class TestFilteringProcessors {
                 Integer elementAmount = receivedElements.get(element) + 1;
                 receivedElements.put(element, elementAmount);
             }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
         receivers = new HashSet<>();

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestParallelExtractionProcessor.java

@@ -13,19 +13,18 @@ import java.util.Map;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-import com.sap.sse.datamining.test.components.util.Number;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
 import com.sap.sse.datamining.test.util.FunctionTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
+import com.sap.sse.datamining.test.util.components.Number;
 
 public class TestParallelExtractionProcessor {
     
-    private Collection<Processor<GroupedDataEntry<Integer>>> receivers;
+    private Collection<Processor<GroupedDataEntry<Integer>, ?>> receivers;
     private Map<GroupKey, Integer> receivedValues;
     
     private Function<Integer> getCrossSumFunction;
@@ -39,24 +38,12 @@ public class TestParallelExtractionProcessor {
     public void initializeReceivers() {
         receivedValues = new HashMap<>();
         
-        Processor<GroupedDataEntry<Integer>> receiver = new Processor<GroupedDataEntry<Integer>>() {
+        @SuppressWarnings("unchecked")
+        Processor<GroupedDataEntry<Integer>, Void> receiver = new NullProcessor<GroupedDataEntry<Integer>, Void>((Class<GroupedDataEntry<Integer>>)(Class<?>) GroupedDataEntry.class, Void.class) {
             @Override
             public void processElement(GroupedDataEntry<Integer> element) {
                 receivedValues.put(element.getKey(), element.getDataEntry());
             }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
         receivers = new HashSet<>();
@@ -66,17 +53,17 @@ public class TestParallelExtractionProcessor {
     @Before
     public void initializeExtractionFunctions() {
         Method getCrossSumMethod = FunctionTestsUtil.getMethodFromClass(Number.class, "getCrossSum");
-        getCrossSumFunction = FunctionFactory.createMethodWrappingFunction(getCrossSumMethod);
+        getCrossSumFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getCrossSumMethod);
         
         Method invalidMethod = FunctionTestsUtil.getMethodFromSimpleClassWithMarkedMethod("sideEffectFreeValue");
-        invalidFunction = FunctionFactory.createMethodWrappingFunction(invalidMethod);
+        invalidFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(invalidMethod);
     }
 
     @Test
     public void testValueExtraction() {
-        Processor<GroupedDataEntry<Number>> processor = new ParallelGroupedElementsValueExtractionProcessor<Number, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, getCrossSumFunction);
+        Processor<GroupedDataEntry<Number>, GroupedDataEntry<Integer>> processor = new ParallelGroupedElementsValueExtractionProcessor<Number, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, getCrossSumFunction);
         Collection<GroupedDataEntry<Number>> elements = createElements();
-        processElements(processor, elements);
+        ConcurrencyTestsUtil.processElements(processor, elements);
         ConcurrencyTestsUtil.sleepFor(100); //Giving the processor time to finish the instructions
         
         Collection<GroupedDataEntry<Integer>> expectedReceivedValues = buildExpectedReceivedValues(elements);
@@ -92,8 +79,8 @@ public class TestParallelExtractionProcessor {
     
     @Test
     public void testValueExtractionWithInvalidFunction() {
-        Processor<GroupedDataEntry<Number>> processor = new ParallelGroupedElementsValueExtractionProcessor<Number, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, invalidFunction);
-        processElements(processor, createElements());
+        Processor<GroupedDataEntry<Number>, GroupedDataEntry<Integer>> processor = new ParallelGroupedElementsValueExtractionProcessor<Number, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, invalidFunction);
+        ConcurrencyTestsUtil.processElements(processor, createElements());
         ConcurrencyTestsUtil.sleepFor(100); //Giving the processor time to finish the instructions
         assertThat("Values have been received, but the processor function is invalid.", receivedValues.isEmpty(), is(true));
     }
@@ -107,12 +94,6 @@ public class TestParallelExtractionProcessor {
         return elements;
     }
 
-    private void processElements(Processor<GroupedDataEntry<Number>> processor, Collection<GroupedDataEntry<Number>> elements) {
-        for (GroupedDataEntry<Number> element : elements) {
-            processor.processElement(element);
-        }
-    }
-
     private Collection<GroupedDataEntry<Integer>> buildExpectedReceivedValues(Collection<GroupedDataEntry<Number>> elements) {
         Collection<GroupedDataEntry<Integer>> expectedReceivedValues = new ArrayList<>();
         for (GroupedDataEntry<Number> element : elements) {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestParallelMultiDimensionalGroupingProcessor.java

@@ -6,75 +6,67 @@ import static org.junit.Assert.assertThat;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.impl.functions.MethodWrappingFunction;
 import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.impl.CompoundGroupKey;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
-import com.sap.sse.datamining.test.components.util.Number;
+import com.sap.sse.datamining.test.util.ComponentTestsUtil;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
 import com.sap.sse.datamining.test.util.FunctionTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
+import com.sap.sse.datamining.test.util.components.Number;
 
 public class TestParallelMultiDimensionalGroupingProcessor {
     
-    private Processor<Number> processor;
-    private Collection<Processor<GroupedDataEntry<Number>>> receivers;
+    private Processor<Number, GroupedDataEntry<Number>> processor;
+    private Collection<Processor<GroupedDataEntry<Number>, ?>> receivers;
 
     private GroupedDataEntry<Number> groupedElement;
 
     @Before
     public void intializeProcessor() throws IllegalArgumentException, NoSuchMethodException, SecurityException {
-        Processor<GroupedDataEntry<Number>> receiver = new Processor<GroupedDataEntry<Number>>() {
+        @SuppressWarnings("unchecked")
+        Processor<GroupedDataEntry<Number>, Void> receiver = new NullProcessor<GroupedDataEntry<Number>, Void>((Class<GroupedDataEntry<Number>>)(Class<?>) GroupedDataEntry.class, Void.class) {
             @Override
             public void processElement(GroupedDataEntry<Number> element) {
                 groupedElement = element;
             }
-            @Override
-            public void onFailure(Throwable failure) { }
-            @Override
-            public void finish() throws InterruptedException { }
-            @Override
-            public void abort() { }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
         receivers = new ArrayList<>();
         receivers.add(receiver);
         
-        Collection<Function<?>> dimensions = new ArrayList<Function<?>>();
+        List<Function<?>> dimensions = new ArrayList<Function<?>>();
         dimensions.add(new MethodWrappingFunction<>(Number.class.getMethod("getLength", new Class<?>[0]), int.class));
         dimensions.add(new MethodWrappingFunction<>(Number.class.getMethod("getCrossSum", new Class<?>[0]), int.class));
         
-        processor = new ParallelMultiDimensionsValueNestingGroupingProcessor<Number>(ConcurrencyTestsUtil.getExecutor(), receivers, dimensions);
+        processor = ComponentTestsUtil.getProcessorFactory().createGroupingProcessor(Number.class, receivers, dimensions);
     }
     
     @Test(expected=IllegalArgumentException.class)
     public void testConstructionWithNullDimensions() {
-        new ParallelMultiDimensionsValueNestingGroupingProcessor<>(ConcurrencyTestsUtil.getExecutor(), receivers, null);
+        new ParallelMultiDimensionsValueNestingGroupingProcessor<>(Number.class, ConcurrencyTestsUtil.getExecutor(), receivers, null);
     }
     
     @Test(expected=IllegalArgumentException.class)
     public void testConstructionWithEmptyDimensions() {
         Iterable<Function<?>> dimensions = new ArrayList<>();
-        new ParallelMultiDimensionsValueNestingGroupingProcessor<>(ConcurrencyTestsUtil.getExecutor(), receivers, dimensions);
+        new ParallelMultiDimensionsValueNestingGroupingProcessor<>(Number.class, ConcurrencyTestsUtil.getExecutor(), receivers, dimensions);
     }
     
     @Test(expected=IllegalArgumentException.class)
     public void testConstructionWithFunctionsInsteadOfDimensions() {
         Collection<Function<?>> functions = new ArrayList<>();
         Method method = FunctionTestsUtil.getMethodFromSimpleClassWithMarkedMethod("sideEffectFreeValue");
-        functions.add(FunctionFactory.createMethodWrappingFunction(method));
-        new ParallelMultiDimensionsValueNestingGroupingProcessor<>(ConcurrencyTestsUtil.getExecutor(), receivers, functions);
+        functions.add(FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(method));
+        new ParallelMultiDimensionsValueNestingGroupingProcessor<>(Number.class, ConcurrencyTestsUtil.getExecutor(), receivers, functions);
     }
 
     @Test

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestPartitioningOfAbstractSimpleParallelProcessor.java

@@ -20,7 +20,7 @@ public class TestPartitioningOfAbstractSimpleParallelProcessor {
 
     @Test
     public void testPartitioning() {
-        Processor<Integer> processor = new AbstractSimpleParallelProcessor<Integer, Integer>(FunctionTestsUtil.getExecutor(), new HashSet<Processor<Integer>>()) {
+        Processor<Integer, Integer> processor = new AbstractSimpleParallelProcessor<Integer, Integer>(Integer.class, Integer.class, FunctionTestsUtil.getExecutor(), new HashSet<Processor<Integer, ?>>()) {
             @Override
             protected Iterable<Integer> partitionElement(Integer element) {
                 partitionedElements = super.partitionElement(element);

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/TestRetrieverFilterProcessorChain.java

@@ -13,14 +13,15 @@ import java.util.Set;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.criterias.AbstractFilterCriterion;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
-public class TestAbstractFilteringRetrievalProcessor {
+public class TestRetrieverFilterProcessorChain {
     
-    private Processor<Iterable<Integer>> filteringRetrievalProcessor;
+    private Processor<Iterable<Integer>, Integer> retrievalProcessor;
     private Collection<Integer> dataSource;
     
     private Collection<Integer> receivedResults = new ArrayList<>();
@@ -32,8 +33,8 @@ public class TestAbstractFilteringRetrievalProcessor {
 
     @Test
     public void testFiltration() throws InterruptedException {
-        filteringRetrievalProcessor.processElement(dataSource);
-        filteringRetrievalProcessor.finish();
+        retrievalProcessor.processElement(dataSource);
+        retrievalProcessor.finish();
         ConcurrencyTestsUtil.sleepFor(500); //Giving the processor time to finish
 
         Collection<Integer> expectedResults = Arrays.asList(0, 1, 2);
@@ -49,14 +50,14 @@ public class TestAbstractFilteringRetrievalProcessor {
 
     @Test
     public void testProvidedAdditionalData() throws InterruptedException {
-        filteringRetrievalProcessor.processElement(dataSource);
-        filteringRetrievalProcessor.finish();
+        retrievalProcessor.processElement(dataSource);
+        retrievalProcessor.finish();
         ConcurrencyTestsUtil.sleepFor(500); //Giving the processor time to finish
         
         int expectedRetrievedDataAmount = receivedResults.size();
         
         OverwritingResultDataBuilder resultDataBuilder = new OverwritingResultDataBuilder();
-        filteringRetrievalProcessor.getAdditionalResultData(resultDataBuilder);
+        retrievalProcessor.getAdditionalResultData(resultDataBuilder);
         assertThat(resultDataBuilder.getRetrievedDataAmount(), is(expectedRetrievedDataAmount));
     }
     
@@ -67,7 +68,11 @@ public class TestAbstractFilteringRetrievalProcessor {
         layeredDataSource.add(dataSource);
         layeredDataSource.add(dataSource);
         
-        Processor<Iterable<Iterable<Integer>>> layeredRetrievalProcessor = new AbstractSimpleRetrievalProcessor<Iterable<Iterable<Integer>>, Iterable<Integer>>(ConcurrencyTestsUtil.getExecutor(), Arrays.asList(filteringRetrievalProcessor)) {
+        Collection<Processor<Iterable<Integer>, ?>> resultReceivers = new ArrayList<>();
+        resultReceivers.add(retrievalProcessor);
+        @SuppressWarnings("unchecked")
+        Processor<Iterable<Iterable<Integer>>, Iterable<Integer>> layeredRetrievalProcessor = new AbstractSimpleRetrievalProcessor<Iterable<Iterable<Integer>>, Iterable<Integer>>((Class<Iterable<Iterable<Integer>>>)(Class<?>) Iterable.class, (Class<Iterable<Integer>>)(Class<?>) Iterable.class,
+                                                                                                                                                                                    ConcurrencyTestsUtil.getExecutor(), resultReceivers) {
             @Override
             protected Iterable<Iterable<Integer>> retrieveData(Iterable<Iterable<Integer>> element) {
                 return element;
@@ -85,37 +90,31 @@ public class TestAbstractFilteringRetrievalProcessor {
         assertThat(resultDataBuilder.getRetrievedDataAmount(), is(expectedRetrievedDataAmount));
     }
     
+    @SuppressWarnings("unchecked")
     @Before
-    public void setUpResultReceiverAndProcessor() {
-        Processor<Integer> resultReceiver = new Processor<Integer>() {
+    public void setUpResultReceiverAndProcessors() {
+        Processor<Integer, Void> resultReceiver = new NullProcessor<Integer, Void>(Integer.class, Void.class) {
             @Override
             public void processElement(Integer element) {
                 synchronized (receivedResults) {
                     receivedResults.add(element);
                 }
             }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
+        Collection<Processor<Integer, ?>> filtrationResultReceivers = new ArrayList<>();
+        filtrationResultReceivers.add(resultReceiver);
         
-        FilterCriterion<Integer> elementGreaterZeroFilterCriteria = new FilterCriterion<Integer>() {
+        FilterCriterion<Integer> elementGreaterZeroFilterCriteria = new AbstractFilterCriterion<Integer>(Integer.class) {
             @Override
             public boolean matches(Integer element) {
                 return element >= 0;
             }
         };
-        filteringRetrievalProcessor = new AbstractSimpleFilteringRetrievalProcessor<Iterable<Integer>, Integer>(ConcurrencyTestsUtil.getExecutor(), Arrays.asList(resultReceiver), elementGreaterZeroFilterCriteria) {
+        Processor<Integer, Integer> filtrationProcessor = new ParallelFilteringProcessor<>(Integer.class, ConcurrencyTestsUtil.getExecutor(), filtrationResultReceivers, elementGreaterZeroFilterCriteria);
+        
+        Collection<Processor<Integer, ?>> retrievalResultReceivers = new ArrayList<>();
+        retrievalResultReceivers.add(filtrationProcessor);
+        retrievalProcessor = new AbstractSimpleRetrievalProcessor<Iterable<Integer>, Integer>((Class<Iterable<Integer>>)(Class<?>) Iterable.class, Integer.class, ConcurrencyTestsUtil.getExecutor(), retrievalResultReceivers) {
             @Override
             protected Iterable<Integer> retrieveData(Iterable<Integer> element) {
                 return element;

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/aggregators/TestAbstractStoringParallelAggregationProcessor.java

@@ -10,14 +10,13 @@ import java.util.HashSet;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
-import com.sap.sse.datamining.shared.Message;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
 public class TestAbstractStoringParallelAggregationProcessor {
 
-    private Collection<Processor<Integer>> receivers;
+    private Collection<Processor<Integer, ?>> receivers;
     private boolean receiverWasToldToFinish = false;
     private Integer receivedElement = null;
     
@@ -25,25 +24,15 @@ public class TestAbstractStoringParallelAggregationProcessor {
     
     @Before
     public void initializeReceivers() {
-        Processor<Integer> receiver = new Processor<Integer>() {
+        Processor<Integer, Void> receiver = new NullProcessor<Integer, Void>(Integer.class, Void.class) {
             @Override
             public void processElement(Integer element) {
                 receivedElement = element;
             }
             @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
             public void finish() throws InterruptedException {
                 receiverWasToldToFinish = true;
             }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
         receivers = new HashSet<>();
@@ -52,7 +41,7 @@ public class TestAbstractStoringParallelAggregationProcessor {
 
     @Test
     public void testAbstractAggregationHandling() throws InterruptedException {
-        Processor<Integer> processor = new AbstractParallelStoringAggregationProcessor<Integer, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, Message.Sum.toString()) {
+        Processor<Integer, Integer> processor = new AbstractParallelStoringAggregationProcessor<Integer, Integer>(Integer.class, Integer.class, ConcurrencyTestsUtil.getExecutor(), receivers, "Sum") {
             @Override
             protected void storeElement(Integer element) {
                 elementStore.add(element);
@@ -76,7 +65,7 @@ public class TestAbstractStoringParallelAggregationProcessor {
         assertThat(receivedElement, is(expectedReceivedElement));
     }
 
-    private void processElementAndVerifyThatItWasStored(Processor<Integer> processor, int element) {
+    private void processElementAndVerifyThatItWasStored(Processor<Integer, Integer> processor, int element) {
         processor.processElement(element);
         ConcurrencyTestsUtil.sleepFor(100); //Giving the processor time to process the instructions
         assertThat("The element store doesn't contain the previously processed element '" + element + "'", elementStore.contains(element), is(true));
@@ -84,7 +73,7 @@ public class TestAbstractStoringParallelAggregationProcessor {
     
     @Test(timeout=5000)
     public void testThatTheLockIsReleasedAfterStoringFailed() throws InterruptedException {
-        Processor<Integer> processor = new AbstractParallelStoringAggregationProcessor<Integer, Integer>(ConcurrencyTestsUtil.getExecutor(), receivers, Message.Sum.toString()) {
+        Processor<Integer, Integer> processor = new AbstractParallelStoringAggregationProcessor<Integer, Integer>(Integer.class, Integer.class, ConcurrencyTestsUtil.getExecutor(), receivers, "Sum") {
             @Override
             protected void storeElement(Integer element) {
                 if (element < 0) {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/aggregators/TestParallelDoubleAggregationProcessors.java

@@ -11,21 +11,23 @@ import java.util.Map.Entry;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
 import com.sap.sse.datamining.shared.GroupKey;
+import com.sap.sse.datamining.shared.components.AggregatorType;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
+import com.sap.sse.datamining.test.util.ComponentTestsUtil;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
 public class TestParallelDoubleAggregationProcessors {
     
-    private Collection<Processor<Map<GroupKey, Double>>> receivers;
+    private Collection<Processor<Map<GroupKey, Double>, ?>> receivers;
     private Map<GroupKey, Double> receivedAggregations;
 
     @Test
     public void testSumAggregationProcessor() throws InterruptedException {
-        Processor<GroupedDataEntry<Double>> sumAggregationProcessor = new ParallelGroupedDoubleDataSumAggregationProcessor(ConcurrencyTestsUtil.getExecutor(), receivers);
+        Processor<GroupedDataEntry<Double>, Map<GroupKey, Double>> sumAggregationProcessor = ComponentTestsUtil.getProcessorFactory().createAggregationProcessor(receivers, AggregatorType.Sum);
         Collection<GroupedDataEntry<Double>> elements = createElements();
         ConcurrencyTestsUtil.processElements(sumAggregationProcessor, elements);
         
@@ -49,7 +51,7 @@ public class TestParallelDoubleAggregationProcessors {
 
     @Test
     public void testAverageAggregationProcessor() throws InterruptedException {
-        Processor<GroupedDataEntry<Double>> averageAggregationProcessor = new ParallelGroupedDoubleDataAverageAggregationProcessor(ConcurrencyTestsUtil.getExecutor(), receivers);
+        Processor<GroupedDataEntry<Double>, Map<GroupKey, Double>> averageAggregationProcessor = ComponentTestsUtil.getProcessorFactory().createAggregationProcessor(receivers, AggregatorType.Average);
         Collection<GroupedDataEntry<Double>> elements = createElements();
         ConcurrencyTestsUtil.processElements(averageAggregationProcessor, elements);
         
@@ -85,7 +87,7 @@ public class TestParallelDoubleAggregationProcessors {
 
     @Test
     public void testMedianAggregationProcessor() throws InterruptedException {
-        Processor<GroupedDataEntry<Double>> medianAggregationProcessor = new ParallelGroupedDoubleDataMedianAggregationProcessor(ConcurrencyTestsUtil.getExecutor(), receivers);
+        Processor<GroupedDataEntry<Double>, Map<GroupKey, Double>> medianAggregationProcessor = ComponentTestsUtil.getProcessorFactory().createAggregationProcessor(receivers, AggregatorType.Median);
         Collection<GroupedDataEntry<Double>> elements = createElements();
         ConcurrencyTestsUtil.processElements(medianAggregationProcessor, elements);
         
@@ -157,24 +159,12 @@ public class TestParallelDoubleAggregationProcessors {
     
     @Before
     public void initializeResultReceivers() {
-        Processor<Map<GroupKey, Double>> receiver = new Processor<Map<GroupKey,Double>>() {
+        @SuppressWarnings("unchecked")
+        Processor<Map<GroupKey, Double>, Void> receiver = new NullProcessor<Map<GroupKey, Double>, Void>((Class<Map<GroupKey, Double>>)(Class<?>) Map.class, Void.class) {
             @Override
             public void processElement(Map<GroupKey, Double> element) {
                 receivedAggregations = element;
             }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
         receivers = new ArrayList<>();

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/components/aggregators/TestParallelGroupedDataCollectingAsSetProcessor.java

@@ -10,38 +10,26 @@ import java.util.Set;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.AdditionalResultDataBuilder;
 import com.sap.sse.datamining.components.Processor;
 import com.sap.sse.datamining.impl.components.GroupedDataEntry;
 import com.sap.sse.datamining.shared.GroupKey;
 import com.sap.sse.datamining.shared.impl.GenericGroupKey;
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
+import com.sap.sse.datamining.test.util.components.NullProcessor;
 
 public class TestParallelGroupedDataCollectingAsSetProcessor {
 
-    private Collection<Processor<Map<GroupKey, Set<Double>>>> receivers;
+    private Collection<Processor<Map<GroupKey, Set<Double>>, ?>> receivers;
     private Map<GroupKey, Set<Double>> receivedData = null;
     
     @Before
     public void initializeReceivers() {
-        Processor<Map<GroupKey, Set<Double>>> receiver = new Processor<Map<GroupKey, Set<Double>>>() {
+        @SuppressWarnings("unchecked")
+        Processor<Map<GroupKey, Set<Double>>, Void> receiver = new NullProcessor<Map<GroupKey, Set<Double>>, Void>((Class<Map<GroupKey, Set<Double>>>)(Class<?>) Map.class, Void.class) {
             @Override
             public void processElement(Map<GroupKey, Set<Double>> element) {
                 receivedData = element;
             }
-            @Override
-            public void onFailure(Throwable failure) {
-            }
-            @Override
-            public void finish() throws InterruptedException {
-            }
-            @Override
-            public void abort() {
-            }
-            @Override
-            public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
-                return additionalDataBuilder;
-            }
         };
         
         receivers = new HashSet<>();
@@ -50,7 +38,7 @@ public class TestParallelGroupedDataCollectingAsSetProcessor {
 
     @Test
     public void testDataCollecting() throws InterruptedException {
-        Processor<GroupedDataEntry<Double>> collectingProcessor = new ParallelGroupedDataCollectingAsSetProcessor<Double>(ConcurrencyTestsUtil.getExecutor(), receivers);
+        Processor<GroupedDataEntry<Double>, Map<GroupKey, Set<Double>>> collectingProcessor = new ParallelGroupedDataCollectingAsSetProcessor<Double>(ConcurrencyTestsUtil.getExecutor(), receivers);
         Collection<GroupedDataEntry<Double>> elements = createElements();
         
         ConcurrencyTestsUtil.processElements(collectingProcessor, elements);

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/criterias/TestFilterCriteria.java

@@ -0,0 +1,88 @@
+package com.sap.sse.datamining.impl.criterias;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Test;
+
+import com.sap.sse.datamining.components.FilterCriterion;
+import com.sap.sse.datamining.functions.Function;
+import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContext;
+import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContextImpl;
+import com.sap.sse.datamining.test.util.FunctionTestsUtil;
+import com.sap.sse.datamining.test.util.StringRegexFilterCriterion;
+
+public class TestFilterCriteria {
+    
+    @Test
+    public void testNonFilteringFilterCriterion() {
+        FilterCriterion<String> nonFilteringFilterCriterion = new NonFilteringFilterCriterion<>(String.class);
+        assertTrue(nonFilteringFilterCriterion.matches("Test"));
+        assertTrue(nonFilteringFilterCriterion.matches(""));
+        assertTrue(nonFilteringFilterCriterion.matches(null));
+    }
+
+    @Test
+    public void testRegexFilterCriterion() {
+        FilterCriterion<String> regexFilterCriterion = new StringRegexFilterCriterion(".*");
+        assertTrue(regexFilterCriterion.matches("some Random stuff"));
+        assertFalse(regexFilterCriterion.matches(null));
+        
+        String[] stringsToMatch = new String[] {"Regatta", "Other Regatta", "Third Regatta"};
+        
+        regexFilterCriterion = new StringRegexFilterCriterion(stringsToMatch[0] + "|" + stringsToMatch[1] + "|" + stringsToMatch[2]);
+        for (String stringToMatch : stringsToMatch) {
+            assertTrue("Failed to match " + stringToMatch, regexFilterCriterion.matches(stringToMatch));
+        }
+        assertFalse("'Fourth Regatta' shouldn't be matched", regexFilterCriterion.matches("Fourth Regatta"));
+        
+        regexFilterCriterion = new StringRegexFilterCriterion(".*Regatta");
+        for (String stringToMatch : stringsToMatch) {
+            assertTrue("Failed to match " + stringToMatch, regexFilterCriterion.matches(stringToMatch));
+        }
+        assertFalse("'Regatta (29ER)' shouldn't be matched", regexFilterCriterion.matches("Regatta (29ER)"));
+    }
+    
+    @Test
+    public void testCompoundFilterCriterion() {
+        StringRegexFilterCriterion startsWithBar = new StringRegexFilterCriterion("Bar.*");
+        StringRegexFilterCriterion endWithFoo = new StringRegexFilterCriterion(".*Foo");
+        
+        CompoundFilterCriterion<String> compoundCriterion = new AndCompoundFilterCriterion<String>(String.class);
+        compoundCriterion.addCriteria(startsWithBar);
+        compoundCriterion.addCriteria(endWithFoo);
+        
+        assertTrue(compoundCriterion.matches("BarAndFoo"));
+        assertFalse(compoundCriterion.matches("BarFo"));
+        
+        compoundCriterion = new OrCompoundFilterCriterion<String>(String.class);
+        compoundCriterion.addCriteria(startsWithBar);
+        compoundCriterion.addCriteria(endWithFoo);
+
+        assertTrue(compoundCriterion.matches("BarF"));
+        assertTrue(compoundCriterion.matches("BraFoo"));
+        assertFalse(compoundCriterion.matches("Nothing"));
+    }
+    
+    @Test
+    public void testNullaryFunctionValuesFilterCriterion() {
+        Function<String> getRegattaName = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeWithContext.class, "getRegattaName"));
+        Collection<String> valuesToMatch = Arrays.asList("Regatta", "Other Regatta");
+        FilterCriterion<DataTypeWithContext> nullaryFunctionFilterCriterion = new NullaryFunctionValuesFilterCriterion<>(DataTypeWithContext.class, getRegattaName, valuesToMatch);
+        
+        DataTypeWithContext regatta = new DataTypeWithContextImpl("Regatta", "Race Name", 7);
+        assertThat(nullaryFunctionFilterCriterion.matches(regatta), is(true));
+        
+        DataTypeWithContext otherRegatta = new DataTypeWithContextImpl("Other Regatta", "Race Name", 7);
+        assertThat(nullaryFunctionFilterCriterion.matches(otherRegatta), is(true));
+        
+        DataTypeWithContext unmatchingRegatta = new DataTypeWithContextImpl("Unmatching Regatta", "Race Name", 7);
+        assertThat(nullaryFunctionFilterCriterion.matches(unmatchingRegatta), is(false));
+    }
+    
+}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/criterias/TestFilterCriterias.java

@@ -1,81 +0,0 @@
-package com.sap.sse.datamining.impl.criterias;
-
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Arrays;
-import java.util.Collection;
-
-import org.junit.Test;
-
-import com.sap.sse.datamining.components.FilterCriterion;
-import com.sap.sse.datamining.factories.FunctionFactory;
-import com.sap.sse.datamining.functions.Function;
-import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContext;
-import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContextImpl;
-import com.sap.sse.datamining.test.util.FunctionTestsUtil;
-import com.sap.sse.datamining.test.util.StringRegexFilterCriterion;
-
-public class TestFilterCriterias {
-
-    @Test
-    public void testRegexFilterCriteria() {
-        FilterCriterion<String> regexFilterCriteria = new StringRegexFilterCriterion(".*");
-        assertTrue(regexFilterCriteria.matches("some Random stuff"));
-        assertFalse(regexFilterCriteria.matches(null));
-        
-        String[] stringsToMatch = new String[] {"Regatta", "Other Regatta", "Third Regatta"};
-        
-        regexFilterCriteria = new StringRegexFilterCriterion(stringsToMatch[0] + "|" + stringsToMatch[1] + "|" + stringsToMatch[2]);
-        for (String stringToMatch : stringsToMatch) {
-            assertTrue("Failed to match " + stringToMatch, regexFilterCriteria.matches(stringToMatch));
-        }
-        assertFalse("'Fourth Regatta' shouldn't be matched", regexFilterCriteria.matches("Fourth Regatta"));
-        
-        regexFilterCriteria = new StringRegexFilterCriterion(".*Regatta");
-        for (String stringToMatch : stringsToMatch) {
-            assertTrue("Failed to match " + stringToMatch, regexFilterCriteria.matches(stringToMatch));
-        }
-        assertFalse("'Regatta (29ER)' shouldn't be matched", regexFilterCriteria.matches("Regatta (29ER)"));
-    }
-    
-    @Test
-    public void testCompoundFilterCriterias() {
-        StringRegexFilterCriterion startsWithBar = new StringRegexFilterCriterion("Bar.*");
-        StringRegexFilterCriterion endWithFoo = new StringRegexFilterCriterion(".*Foo");
-        
-        CompoundFilterCriterion<String> compoundCriteria = new AndCompoundFilterCriterion<String>();
-        compoundCriteria.addCriteria(startsWithBar);
-        compoundCriteria.addCriteria(endWithFoo);
-        
-        assertTrue(compoundCriteria.matches("BarAndFoo"));
-        assertFalse(compoundCriteria.matches("BarFo"));
-        
-        compoundCriteria = new OrCompoundFilterCriterion<String>();
-        compoundCriteria.addCriteria(startsWithBar);
-        compoundCriteria.addCriteria(endWithFoo);
-
-        assertTrue(compoundCriteria.matches("BarF"));
-        assertTrue(compoundCriteria.matches("BraFoo"));
-        assertFalse(compoundCriteria.matches("Nothing"));
-    }
-    
-    @Test
-    public void testNullaryFunctionValuesFilterCriteria() {
-        Function<String> getRegattaName = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeWithContext.class, "getRegattaName"));
-        Collection<String> valuesToMatch = Arrays.asList("Regatta", "Other Regatta");
-        FilterCriterion<DataTypeWithContext> nullaryFunctionFilterCriteria = new NullaryFunctionValuesFilterCriterion<>(getRegattaName, valuesToMatch);
-        
-        DataTypeWithContext regatta = new DataTypeWithContextImpl("Regatta", "Race Name", 7);
-        assertThat(nullaryFunctionFilterCriteria.matches(regatta), is(true));
-        
-        DataTypeWithContext otherRegatta = new DataTypeWithContextImpl("Other Regatta", "Race Name", 7);
-        assertThat(nullaryFunctionFilterCriteria.matches(otherRegatta), is(true));
-        
-        DataTypeWithContext unmatchingRegatta = new DataTypeWithContextImpl("Unmatching Regatta", "Race Name", 7);
-        assertThat(nullaryFunctionFilterCriteria.matches(unmatchingRegatta), is(false));
-    }
-    
-}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/data/TestClusterGroupRepository.java

@@ -16,7 +16,7 @@ import com.sap.sse.datamining.data.Cluster;
 import com.sap.sse.datamining.data.ClusterBoundary;
 import com.sap.sse.datamining.data.ClusterGroup;
 import com.sap.sse.datamining.data.ClusterGroupRepository;
-import com.sap.sse.datamining.test.components.util.Number;
+import com.sap.sse.datamining.test.util.components.Number;
 
 public class TestClusterGroupRepository {
     
@@ -63,11 +63,11 @@ public class TestClusterGroupRepository {
 
         ClusterBoundary<Number> lengthGreaterEqualsOne = new ComparatorClusterBoundary<Number>(lengthComparator, new Number(0), ComparisonStrategy.GREATER_EQUALS_THAN);
         ClusterBoundary<Number> lengthLowerSix = new ComparatorClusterBoundary<Number>(lengthComparator, new Number(100000), ComparisonStrategy.LOWER_THAN);
-        Cluster<Number> lengthBetweenOneAndFiveCluster = new ClusterWithBoundaries<>("Short", lengthGreaterEqualsOne, lengthLowerSix);
+        Cluster<Number> lengthBetweenOneAndFiveCluster = new ClusterWithLowerAndUpperBoundaries<>("Short", lengthGreaterEqualsOne, lengthLowerSix);
 
         ClusterBoundary<Number> lengthGreaterEqualsSix = new ComparatorClusterBoundary<Number>(lengthComparator, new Number(100000), ComparisonStrategy.GREATER_EQUALS_THAN);
         ClusterBoundary<Number> lengthLowerEqualsTen = new ComparatorClusterBoundary<Number>(lengthComparator, new Number(1000000000), ComparisonStrategy.LOWER_EQUALS_THAN);
-        Cluster<Number> lengthBetweenSixAndTen = new ClusterWithBoundaries<>("Long", lengthGreaterEqualsSix, lengthLowerEqualsTen);
+        Cluster<Number> lengthBetweenSixAndTen = new ClusterWithLowerAndUpperBoundaries<>("Long", lengthGreaterEqualsSix, lengthLowerEqualsTen);
         
         return new FixClusterGroup<>("Number Length", Arrays.asList(lengthBetweenOneAndFiveCluster, lengthBetweenSixAndTen));
     }
@@ -82,11 +82,11 @@ public class TestClusterGroupRepository {
 
         ClusterBoundary<Number> crossSumGreaterEqualsZero = new ComparatorClusterBoundary<Number>(crossSumComparator, new Number(0), ComparisonStrategy.GREATER_EQUALS_THAN);
         ClusterBoundary<Number> crossSumLowerTwentySix = new ComparatorClusterBoundary<Number>(crossSumComparator, new Number(998), ComparisonStrategy.LOWER_THAN);
-        Cluster<Number> crossSumBetweenZeroAndTwentyFiveCluster = new ClusterWithBoundaries<>("Low", crossSumGreaterEqualsZero, crossSumLowerTwentySix);
+        Cluster<Number> crossSumBetweenZeroAndTwentyFiveCluster = new ClusterWithLowerAndUpperBoundaries<>("Low", crossSumGreaterEqualsZero, crossSumLowerTwentySix);
 
         ClusterBoundary<Number> crossSumGreaterEqualsTwentySix = new ComparatorClusterBoundary<Number>(crossSumComparator, new Number(998), ComparisonStrategy.GREATER_EQUALS_THAN);
         ClusterBoundary<Number> crossSumLowerEqualsFifty = new ComparatorClusterBoundary<Number>(crossSumComparator, new Number(999995), ComparisonStrategy.LOWER_EQUALS_THAN);
-        Cluster<Number> lengthBetweenSixAndTen = new ClusterWithBoundaries<>("High", crossSumGreaterEqualsTwentySix, crossSumLowerEqualsFifty);
+        Cluster<Number> lengthBetweenSixAndTen = new ClusterWithLowerAndUpperBoundaries<>("High", crossSumGreaterEqualsTwentySix, crossSumLowerEqualsFifty);
         
         return new FixClusterGroup<>("Number Cross-Sum", Arrays.asList(crossSumBetweenZeroAndTwentyFiveCluster, lengthBetweenSixAndTen));
     }

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/data/TestClustersWithBoundaries.java

@@ -12,6 +12,8 @@ import com.sap.sse.datamining.data.ClusterBoundary;
 
 public class TestClustersWithBoundaries {
 
+    private static final char INFINITE = '\u221e';
+    
     private static final Comparator<Integer> comparator = new ComparableComparator<Integer>();
 
     private static final ClusterBoundary<Integer> lowerBound = new ComparatorClusterBoundary<Integer>(comparator, 0, ComparisonStrategy.GREATER_EQUALS_THAN);
@@ -19,7 +21,7 @@ public class TestClustersWithBoundaries {
 
     @Test
     public void testClusterWithBoundaries() {
-        Cluster<Integer> cluster = new ClusterWithBoundaries<>("Test Cluster", lowerBound, upperBound);
+        Cluster<Integer> cluster = new ClusterWithLowerAndUpperBoundaries<>("Test Cluster", lowerBound, upperBound);
 
         assertThat(cluster.isInRange(0), is(true));
         assertThat(cluster.isInRange(3), is(true));
@@ -27,6 +29,8 @@ public class TestClustersWithBoundaries {
 
         assertThat(cluster.isInRange(-1), is(false));
         assertThat(cluster.isInRange(10), is(false));
+        
+        assertThat(cluster.toString(), is("Test Cluster [0 - 10["));
     }
     
     @Test
@@ -35,15 +39,19 @@ public class TestClustersWithBoundaries {
 
         assertThat(cluster.isInRange(0), is(true));
         assertThat(cluster.isInRange(3), is(true));
-
+        assertThat(cluster.isInRange(Integer.MAX_VALUE), is(true));
         assertThat(cluster.isInRange(-1), is(false));
         
+        assertThat(cluster.toString(), is("Test Cluster [0 - " + INFINITE));
+        
         cluster = new ClusterWithSingleBoundary<>("Test Cluster", upperBound);
 
+        assertThat(cluster.isInRange(Integer.MIN_VALUE), is(true));
         assertThat(cluster.isInRange(9), is(true));
-
         assertThat(cluster.isInRange(10), is(false));
         assertThat(cluster.isInRange(11), is(false));
+        
+        assertThat(cluster.toString(), is("Test Cluster -" + INFINITE + " - 10["));
     }
 
 }

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/data/TestComparableClusterBoundary.java

@@ -3,48 +3,52 @@ package com.sap.sse.datamining.impl.data;
 import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertThat;
 
-import java.util.Comparator;
-
 import org.junit.Test;
 
 import com.sap.sse.datamining.data.ClusterBoundary;
 
-public class TestComparatorClusterBoundary {
-
-    public static final Comparator<Integer> comparator = new ComparableComparator<Integer>();
+public class TestComparableClusterBoundary {
 
     @Test
     public void testGreaterEqualsThanStrategy() {
-        ClusterBoundary<Integer> greaterEqualsThan5Bound = new ComparatorClusterBoundary<Integer>(comparator, 5, ComparisonStrategy.GREATER_EQUALS_THAN);
+        ClusterBoundary<Integer> greaterEqualsThan5Bound = new ComparableClusterBoundary<Integer>(5, ComparisonStrategy.GREATER_EQUALS_THAN);
 
         assertThat(greaterEqualsThan5Bound.contains(6), is(true));
         assertThat(greaterEqualsThan5Bound.contains(5), is(true));
         assertThat(greaterEqualsThan5Bound.contains(4), is(false));
+        
+        assertThat(greaterEqualsThan5Bound.toString(), is("[5"));
     }
 
     @Test
     public void testGreaterThanStrategy() {
-        ClusterBoundary<Integer> greaterThan5Bound = new ComparatorClusterBoundary<Integer>(comparator, 5, ComparisonStrategy.GREATER_THAN);
+        ClusterBoundary<Integer> greaterThan5Bound = new ComparableClusterBoundary<Integer>(5, ComparisonStrategy.GREATER_THAN);
 
         assertThat(greaterThan5Bound.contains(6), is(true));
         assertThat(greaterThan5Bound.contains(5), is(false));
+        
+        assertThat(greaterThan5Bound.toString(), is("]5"));
     }
 
     @Test
     public void testLowerEqualsThanStrategy() {
-        ClusterBoundary<Integer> lowerEqualsThan5Bound = new ComparatorClusterBoundary<Integer>(comparator, 5, ComparisonStrategy.LOWER_EQUALS_THAN);
+        ClusterBoundary<Integer> lowerEqualsThan5Bound = new ComparableClusterBoundary<Integer>(5, ComparisonStrategy.LOWER_EQUALS_THAN);
 
         assertThat(lowerEqualsThan5Bound.contains(4), is(true));
         assertThat(lowerEqualsThan5Bound.contains(5), is(true));
         assertThat(lowerEqualsThan5Bound.contains(6), is(false));
+        
+        assertThat(lowerEqualsThan5Bound.toString(), is("5]"));
     }
 
     @Test
     public void testLowerThanStrategy() {
-        ClusterBoundary<Integer> lowerThan5Bound = new ComparatorClusterBoundary<Integer>(comparator, 5, ComparisonStrategy.LOWER_THAN);
+        ClusterBoundary<Integer> lowerThan5Bound = new ComparableClusterBoundary<Integer>(5, ComparisonStrategy.LOWER_THAN);
 
         assertThat(lowerThan5Bound.contains(4), is(true));
         assertThat(lowerThan5Bound.contains(5), is(false));
+        
+        assertThat(lowerThan5Bound.toString(), is("5["));
     }
 
 }

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/data/TestFixClusterGroup.java

@@ -75,15 +75,15 @@ public class TestFixClusterGroup {
         
         ClusterBoundary<Integer> greaterEqualsThanZero = new ComparatorClusterBoundary<Integer>(new ComparableComparator<Integer>(), 0, ComparisonStrategy.GREATER_EQUALS_THAN);
         ClusterBoundary<Integer> lowerEqualsThanTen = new ComparatorClusterBoundary<Integer>(new ComparableComparator<Integer>(), 10, ComparisonStrategy.LOWER_EQUALS_THAN);
-        clusterFromZeroToTen = new ClusterWithBoundaries<>("Test", greaterEqualsThanZero, lowerEqualsThanTen);
+        clusterFromZeroToTen = new ClusterWithLowerAndUpperBoundaries<>("Test", greaterEqualsThanZero, lowerEqualsThanTen);
 
         ClusterBoundary<Integer> greaterThanTen = new ComparatorClusterBoundary<Integer>(new ComparableComparator<Integer>(), 10, ComparisonStrategy.GREATER_THAN);
         ClusterBoundary<Integer> lowerEqualsThanTwenty = new ComparatorClusterBoundary<Integer>(new ComparableComparator<Integer>(), 20, ComparisonStrategy.LOWER_EQUALS_THAN);
-        clusterFromElevenToTwenty = new ClusterWithBoundaries<>("Test", greaterThanTen, lowerEqualsThanTwenty);
+        clusterFromElevenToTwenty = new ClusterWithLowerAndUpperBoundaries<>("Test", greaterThanTen, lowerEqualsThanTwenty);
 
         ClusterBoundary<Integer> greaterThanTwenty = new ComparatorClusterBoundary<Integer>(new ComparableComparator<Integer>(), 20, ComparisonStrategy.GREATER_THAN);
         ClusterBoundary<Integer> lowerEqualsThanThirty = new ComparatorClusterBoundary<Integer>(new ComparableComparator<Integer>(), 30, ComparisonStrategy.LOWER_EQUALS_THAN);
-        clusterFromTwentyOneToThirty = new ClusterWithBoundaries<>("Test", greaterThanTwenty, lowerEqualsThanThirty);
+        clusterFromTwentyOneToThirty = new ClusterWithLowerAndUpperBoundaries<>("Test", greaterThanTwenty, lowerEqualsThanThirty);
 
         ClusterBoundary<Integer> greaterThanThirty = new ComparatorClusterBoundary<Integer>(comparator, 30, ComparisonStrategy.GREATER_THAN);
         clusterGreaterThanThirty = new ClusterWithSingleBoundary<>("Test", greaterThanThirty);

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

@@ -10,13 +10,13 @@ import java.util.Locale;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.shared.Unit;
 import com.sap.sse.datamining.test.functions.test_classes.ContainerElement;
 import com.sap.sse.datamining.test.functions.test_classes.ContainerElementImpl;
 import com.sap.sse.datamining.test.functions.test_classes.MarkedContainer;
 import com.sap.sse.datamining.test.functions.test_classes.MarkedContainerImpl;
+import com.sap.sse.datamining.test.util.FunctionTestsUtil;
 import com.sap.sse.datamining.test.util.TestsUtil;
 
 public class TestCompoundFunction {
@@ -29,12 +29,12 @@ public class TestCompoundFunction {
     @Before
     public void initializeCompoundFunction() throws ClassCastException, NoSuchMethodException, SecurityException {
         List<Function<?>> functions = new ArrayList<>();
-        getContainerElementFunction = FunctionFactory.createMethodWrappingFunction(MarkedContainer.class.getMethod("getContainerElement", new Class<?>[0]));
+        getContainerElementFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(MarkedContainer.class.getMethod("getContainerElement", new Class<?>[0]));
         functions.add(getContainerElementFunction);
-        getNameFunction = FunctionFactory.createMethodWrappingFunction(ContainerElement.class.getMethod("getName", new Class<?>[0]));
+        getNameFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(ContainerElement.class.getMethod("getName", new Class<?>[0]));
         functions.add(getNameFunction);
         
-        compoundFunction = FunctionFactory.createCompoundFunction("TestCompoundFunction", functions);
+        compoundFunction = FunctionTestsUtil.getFunctionFactory().createCompoundFunction("TestCompoundFunction", functions);
     }
 
     @Test(expected=IllegalArgumentException.class)

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

@@ -11,8 +11,6 @@ import java.util.Locale;
 import org.junit.Before;
 import org.junit.Test;
 
-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.i18n.DataMiningStringMessages;
 import com.sap.sse.datamining.shared.dto.FunctionDTO;
@@ -25,7 +23,7 @@ import com.sap.sse.datamining.test.util.TestsUtil;
 public class TestFunctionDTOConstruction {
     
     private static final DataMiningStringMessages stringMessages = TestsUtil.getTestStringMessages();
-    
+
     private Method dimensionMethod;
     private Method sideEffectFreeValueMethod;
     private Method externalLibraryMethod;
@@ -41,12 +39,12 @@ public class TestFunctionDTOConstruction {
 
     @Test
     public void testDimensionDTOConstruction() {
-        Function<?> dimension = FunctionFactory.createMethodWrappingFunction(dimensionMethod);
+        Function<?> dimension = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(dimensionMethod);
         
         FunctionDTO expectedDimensionDTO = createExpectedDimensionDTO();
-        assertThat(FunctionDTOFactory.createFunctionDTO(dimension), is(expectedDimensionDTO));
-        assertThat(FunctionDTOFactory.createFunctionDTO(dimension, Locale.ENGLISH, stringMessages), is(expectedDimensionDTO));
-        assertThat(FunctionDTOFactory.createFunctionDTO(dimension, Locale.GERMAN, stringMessages), is(expectedDimensionDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimension), is(expectedDimensionDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimension, stringMessages, Locale.ENGLISH), is(expectedDimensionDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimension, stringMessages, Locale.GERMAN), is(expectedDimensionDTO));
     }
 
     public FunctionDTOImpl createExpectedDimensionDTO() {
@@ -64,11 +62,11 @@ public class TestFunctionDTOConstruction {
     
     @Test
     public void testNullarySideEffectFreeValueDTOConstruction() {
-        Function<?> sideEffectFreeValue = FunctionFactory.createMethodWrappingFunction(sideEffectFreeValueMethod);
+        Function<?> sideEffectFreeValue = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(sideEffectFreeValueMethod);
         
         FunctionDTO expectedDTO = createExpectedNullarySideEffectFreeValueDTO();
-        assertThat(FunctionDTOFactory.createFunctionDTO(sideEffectFreeValue, Locale.ENGLISH, stringMessages), is(expectedDTO));
-        assertThat(FunctionDTOFactory.createFunctionDTO(sideEffectFreeValue, Locale.GERMAN, stringMessages), is(expectedDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(sideEffectFreeValue, stringMessages, Locale.ENGLISH), is(expectedDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(sideEffectFreeValue, stringMessages, Locale.GERMAN), is(expectedDTO));
     }
 
     private FunctionDTO createExpectedNullarySideEffectFreeValueDTO() {
@@ -86,11 +84,11 @@ public class TestFunctionDTOConstruction {
     
     @Test
     public void testExternalLibraryFunctionDTOConstruction() {
-        Function<?> externalLibraryFunction = FunctionFactory.createMethodWrappingFunction(externalLibraryMethod);
+        Function<?> externalLibraryFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(externalLibraryMethod);
         
         FunctionDTO expectedDTO = createExpectedExternalLibraryFunctionDTO();
-        assertThat(FunctionDTOFactory.createFunctionDTO(externalLibraryFunction, Locale.ENGLISH, stringMessages), is(expectedDTO));
-        assertThat(FunctionDTOFactory.createFunctionDTO(externalLibraryFunction, Locale.GERMAN, stringMessages), is(expectedDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(externalLibraryFunction, stringMessages, Locale.ENGLISH), is(expectedDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(externalLibraryFunction, stringMessages, Locale.GERMAN), is(expectedDTO));
     }
 
     private FunctionDTO createExpectedExternalLibraryFunctionDTO() {
@@ -108,11 +106,11 @@ public class TestFunctionDTOConstruction {
     
     @Test
     public void testFunctionDTOConstructionForMethodWithParameters() {
-        Function<?> increment = FunctionFactory.createMethodWrappingFunction(incrementMethod);
+        Function<?> increment = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(incrementMethod);
         
         FunctionDTO expectedDTO = createFunctionDTOWithParameters();
-        assertThat(FunctionDTOFactory.createFunctionDTO(increment, Locale.ENGLISH, stringMessages), is(expectedDTO));
-        assertThat(FunctionDTOFactory.createFunctionDTO(increment, Locale.GERMAN, stringMessages), is(expectedDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(increment, stringMessages, Locale.ENGLISH), is(expectedDTO));
+        assertThat(FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(increment, stringMessages, Locale.GERMAN), is(expectedDTO));
     }
 
     private FunctionDTO createFunctionDTOWithParameters() {
@@ -131,11 +129,11 @@ public class TestFunctionDTOConstruction {
     
     @Test
     public void testThatLocalizedFunctionDTOAndUnlocalizedAreEqual() {
-        Function<?> dimension = FunctionFactory.createMethodWrappingFunction(dimensionMethod);
+        Function<?> dimension = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(dimensionMethod);
         
-        FunctionDTO unlocalizedDimensionDTO = FunctionDTOFactory.createFunctionDTO(dimension);
-        FunctionDTO englishDimensionDTO = FunctionDTOFactory.createFunctionDTO(dimension, Locale.ENGLISH, TestsUtil.getTestStringMessages());
-        FunctionDTO germanDimensionDTO = FunctionDTOFactory.createFunctionDTO(dimension, Locale.GERMAN, TestsUtil.getTestStringMessages());
+        FunctionDTO unlocalizedDimensionDTO = FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimension);
+        FunctionDTO englishDimensionDTO = FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimension, TestsUtil.getTestStringMessages(), Locale.ENGLISH);
+        FunctionDTO germanDimensionDTO = FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(dimension, TestsUtil.getTestStringMessages(), Locale.GERMAN);
         
         assertThat(unlocalizedDimensionDTO, is(englishDimensionDTO));
         assertThat(englishDimensionDTO, is(germanDimensionDTO));

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

@@ -13,16 +13,18 @@ import java.util.Locale;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.factories.FunctionDTOFactory;
-import com.sap.sse.datamining.factories.FunctionFactory;
+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_contexts.Test_HasLegContext;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegContextImpl;
+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;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContextImpl;
 import com.sap.sse.datamining.test.functions.test_classes.SimpleClassWithMarkedMethods;
@@ -30,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 {
     
@@ -44,7 +49,7 @@ public class TestFunctionProvider {
         functionRegistry = new SimpleFunctionRegistry();
         
         Collection<Class<?>> internalClassesToScan = new HashSet<>();
-        internalClassesToScan.add(Test_HasLegContext.class);
+        internalClassesToScan.add(Test_HasLegOfCompetitorContext.class);
         internalClassesToScan.add(Test_HasRaceContext.class);
         functionRegistry.registerAllWithInternalFunctionPolicy(internalClassesToScan);
         
@@ -68,28 +73,70 @@ public class TestFunctionProvider {
         assertThat(functionProvider.getDimensionsFor(Test_HasRaceContext.class), is(expectedDimensions));
         assertThat(functionProvider.getDimensionsFor(Test_HasRaceContextImpl.class), is(expectedDimensions));
 
-        expectedDimensions.addAll(functionRegistryUtil.getExpectedDimensionsFor(Test_HasLegContext.class));
-        assertThat(functionProvider.getDimensionsFor(Test_HasLegContext.class), is(expectedDimensions));
-        assertThat(functionProvider.getDimensionsFor(Test_HasLegContextImpl.class), is(expectedDimensions));
+        expectedDimensions.addAll(functionRegistryUtil.getExpectedDimensionsFor(Test_HasLegOfCompetitorContext.class));
+        assertThat(functionProvider.getDimensionsFor(Test_HasLegOfCompetitorContext.class), is(expectedDimensions));
+        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);
-        Collection<Function<?>> expectedFunctions = functionRegistryUtil.getExpectedStatisticsFor(Test_HasLegContext.class);
-        assertThat(functionProvider.getStatisticsFor(Test_HasLegContext.class), is(expectedFunctions));
-        assertThat(functionProvider.getStatisticsFor(Test_HasLegContextImpl.class), is(expectedFunctions));
+        Collection<Function<?>> expectedStatistics = functionRegistryUtil.getExpectedStatisticsFor(Test_HasLegOfCompetitorContext.class);
+        assertThat(functionProvider.getStatisticsFor(Test_HasLegOfCompetitorContext.class), is(expectedStatistics));
+        assertThat(functionProvider.getStatisticsFor(Test_HasLegOfCompetitorContextImpl.class), is(expectedStatistics));
+    }
+    
+    @Test
+    public void testGetAllFunctionsForType() {
+        FunctionProvider functionProvider = new RegistryFunctionProvider(functionRegistry);
+        
+        Collection<Function<?>> expectedFunctions = functionRegistryUtil.getExpectedDimensionsFor(Test_HasRaceContext.class);
+        expectedFunctions.addAll(functionRegistryUtil.getExpectedDimensionsFor(Test_HasLegOfCompetitorContext.class));
+        expectedFunctions.addAll(functionRegistryUtil.getExpectedStatisticsFor(Test_HasLegOfCompetitorContext.class));
+        assertThat(functionProvider.getFunctionsFor(Test_HasLegOfCompetitorContext.class), is(expectedFunctions));
+        assertThat(functionProvider.getFunctionsFor(Test_HasLegOfCompetitorContextImpl.class), is(expectedFunctions));
     }
     
     @Test
     public void testGetFunctionForDTO() throws NoSuchMethodException, SecurityException {
         Method getRegattaMethod = Test_HasRaceContext.class.getMethod("getRace", new Class<?>[0]);
-        Function<?> getRegatta = FunctionFactory.createMethodWrappingFunction(getRegattaMethod);
+        Function<?> getRegatta = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getRegattaMethod);
         Method getNameMethod = Test_Named.class.getMethod("getName", new Class<?>[0]);
-        Function<?> getName = FunctionFactory.createMethodWrappingFunction(getNameMethod);
-        Function<Object> getRegattaName = FunctionFactory.createCompoundFunction(Arrays.asList(getRegatta, getName));
+        Function<?> getName = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getNameMethod);
+        Function<Object> getRegattaName = FunctionTestsUtil.getFunctionFactory().createCompoundFunction(Arrays.asList(getRegatta, getName));
         
-        FunctionDTO getRegattaNameDTO = FunctionDTOFactory.createFunctionDTO(getRegattaName, Locale.ENGLISH, stringMessages);
+        FunctionDTO getRegattaNameDTO = FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(getRegattaName, stringMessages, Locale.ENGLISH);
         
         FunctionProvider functionProvider = new RegistryFunctionProvider(functionRegistry);
         @SuppressWarnings("unchecked") // Hamcrest requires type matching of actual and expected type, so the Functions have to be specific (without <?>)
@@ -100,8 +147,8 @@ public class TestFunctionProvider {
     @Test
     public void testGetFunctionForUnregisteredDTO() {
         Method incrementMethod = FunctionTestsUtil.getMethodFromClass(SimpleClassWithMarkedMethods.class, "increment", int.class);
-        Function<Object> increment = FunctionFactory.createMethodWrappingFunction(incrementMethod);
-        FunctionDTO incrementDTO = FunctionDTOFactory.createFunctionDTO(increment, Locale.ENGLISH, stringMessages);
+        Function<Object> increment = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(incrementMethod);
+        FunctionDTO incrementDTO = FunctionTestsUtil.getFunctionDTOFactory().createFunctionDTO(increment, stringMessages, Locale.ENGLISH);
         
         FunctionProvider functionProvider = new RegistryFunctionProvider(functionRegistry);
         assertThat(functionProvider.getFunctionForDTO(incrementDTO), is(nullValue()));

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

@@ -9,7 +9,6 @@ import java.util.Locale;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.i18n.DataMiningStringMessages;
 import com.sap.sse.datamining.test.functions.test_classes.SimpleClassWithMarkedMethods;
@@ -38,13 +37,13 @@ public class TestMethodWrappingFunction {
     
     @Test
     public void testIsDimension() {
-        Function<?> dimension = FunctionFactory.createMethodWrappingFunction(dimensionMethod);
+        Function<?> dimension = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(dimensionMethod);
         assertThat(dimension.isDimension(), is(true));
 
-        Function<?> sideEffectFreeValue = FunctionFactory.createMethodWrappingFunction(sideEffectFreeValueMethod);
+        Function<?> sideEffectFreeValue = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(sideEffectFreeValueMethod);
         assertThat(sideEffectFreeValue.isDimension(), is(false));
 
-        Function<?> externalLibraryFunction = FunctionFactory.createMethodWrappingFunction(externalLibraryMethod);
+        Function<?> externalLibraryFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(externalLibraryMethod);
         assertThat(externalLibraryFunction.isDimension(), is(false));
     }
     
@@ -52,19 +51,19 @@ public class TestMethodWrappingFunction {
     public void testGetLocalizedName() {
         DataMiningStringMessages stringMessages = TestsUtil.getTestStringMessages();
 
-        Function<?> dimension = FunctionFactory.createMethodWrappingFunction(dimensionMethod);
+        Function<?> dimension = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(dimensionMethod);
         String expectedEnglishName = "dimension-english";
         assertThat(dimension.getLocalizedName(Locale.ENGLISH, stringMessages), is(expectedEnglishName));
         String expectedGermanName = "dimension-deutsch";
         assertThat(dimension.getLocalizedName(Locale.GERMAN, stringMessages), is(expectedGermanName));
 
-        Function<?> sideEffectFreeValue = FunctionFactory.createMethodWrappingFunction(sideEffectFreeValueMethod);
+        Function<?> sideEffectFreeValue = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(sideEffectFreeValueMethod);
         expectedEnglishName = "sideEffectFreeValue-english";
         assertThat(sideEffectFreeValue.getLocalizedName(Locale.ENGLISH, stringMessages), is(expectedEnglishName));
         expectedGermanName = "sideEffectFreeValue-deutsch";
         assertThat(sideEffectFreeValue.getLocalizedName(Locale.GERMAN, stringMessages), is(expectedGermanName));
 
-        Function<?> externalLibraryFunction = FunctionFactory.createMethodWrappingFunction(externalLibraryMethod);
+        Function<?> externalLibraryFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(externalLibraryMethod);
         String expectedName = "foo";
         assertThat(externalLibraryFunction.getLocalizedName(Locale.ENGLISH, stringMessages), is(expectedName));
         assertThat(externalLibraryFunction.getLocalizedName(Locale.GERMAN, stringMessages), is(expectedName));

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

@@ -7,7 +7,6 @@ import static org.junit.Assert.assertThat;
 import org.junit.Before;
 import org.junit.Test;
 
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContext;
 import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContextImpl;
@@ -21,8 +20,8 @@ public class TestMethodWrappingFunctionInvocation {
 
     @Before
     public void setUpFunctions() {
-        getRegattaName = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeWithContext.class, "getRegattaName"));
-        increment = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(SimpleClassWithMarkedMethods.class, "increment", int.class));
+        getRegattaName = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeWithContext.class, "getRegattaName"));
+        increment = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(SimpleClassWithMarkedMethods.class, "increment", int.class));
     }
 
     @Test

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

@@ -14,7 +14,7 @@ import org.junit.Test;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.functions.FunctionRegistry;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasContextWithDeadConnectorEnd;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegContext;
+import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegOfCompetitorContext;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContext;
 import com.sap.sse.datamining.test.functions.test_classes.Test_ExternalLibraryClass;
 import com.sap.sse.datamining.test.util.ExpectedFunctionRegistryUtil;
@@ -35,7 +35,7 @@ public class TestSimpleFunctionRegistry {
     @Before
     public void initializeClassesToScan() {
         internalClassesToScan = new HashSet<>();
-        internalClassesToScan.add(Test_HasLegContext.class);
+        internalClassesToScan.add(Test_HasLegOfCompetitorContext.class);
         internalClassesToScan.add(Test_HasRaceContext.class);
         internalClassesToScan.add(Test_HasContextWithDeadConnectorEnd.class);
         
@@ -50,11 +50,11 @@ public class TestSimpleFunctionRegistry {
         registry.registerAllWithExternalFunctionPolicy(externalClassesToScan);
         
         Collection<Function<?>> expectedDimensions = new HashSet<>();
-        expectedDimensions.addAll(expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasLegContext.class));
+        expectedDimensions.addAll(expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasLegOfCompetitorContext.class));
         expectedDimensions.addAll(expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasRaceContext.class));
         assertThat(registry.getDimensions(), is(expectedDimensions));
         
-        Collection<Function<?>> expectedStatistics = expectedFunctionRegistryUtil.getExpectedStatisticsFor(Test_HasLegContext.class);
+        Collection<Function<?>> expectedStatistics = expectedFunctionRegistryUtil.getExpectedStatisticsFor(Test_HasLegOfCompetitorContext.class);
         assertThat(registry.getStatistics(), is(expectedStatistics));
         
         Collection<Function<?>> expectedExternalFunctions = expectedFunctionRegistryUtil.getExpectedExternalFunctionsFor(Test_ExternalLibraryClass.class);
@@ -67,12 +67,12 @@ public class TestSimpleFunctionRegistry {
         registry.registerAllWithInternalFunctionPolicy(internalClassesToScan);
         
         Collection<Function<?>> expectedDimensions = new HashSet<>();
-        expectedDimensions.addAll(expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasLegContext.class));
+        expectedDimensions.addAll(expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasLegOfCompetitorContext.class));
         expectedDimensions.addAll(expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasRaceContext.class));
         assertThat(registry.getDimensions(), is(expectedDimensions));
         
         Set<Class<?>> classesToUnregister = new HashSet<>();
-        classesToUnregister.add(Test_HasLegContext.class);
+        classesToUnregister.add(Test_HasLegOfCompetitorContext.class);
         registry.unregisterAllFunctionsOf(classesToUnregister);
         
         expectedDimensions = expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasRaceContext.class);
@@ -83,7 +83,7 @@ public class TestSimpleFunctionRegistry {
         classesToUnregister.add(Test_HasRaceContext.class);
         registry.unregisterAllFunctionsOf(classesToUnregister);
         
-        expectedDimensions = expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasLegContext.class);
+        expectedDimensions = expectedFunctionRegistryUtil.getExpectedDimensionsFor(Test_HasLegOfCompetitorContext.class);
         assertThat(registry.getDimensions(), is(expectedDimensions));
     }
 

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/functions/criterias/TestDeclaringTypeOrParameterTypeCriteria.java

@@ -7,7 +7,6 @@ import org.junit.Before;
 import org.junit.Test;
 
 import com.sap.sse.datamining.components.FilterCriterion;
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.test.functions.test_classes.DataTypeInterface;
 import com.sap.sse.datamining.test.functions.test_classes.DataTypeWithContext;
@@ -26,11 +25,11 @@ public class TestDeclaringTypeOrParameterTypeCriteria {
     
     @Before
     public void setUpFunctions() {
-        getSpeedInKnotsValue = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeInterface.class, "getSpeedInKnots"));
-        getRaceNameLengthValue = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(ExtendingInterface.class, "getRaceNameLength"));
-        getRegattaNameDimension = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeWithContext.class, "getRegattaName"));
+        getSpeedInKnotsValue = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeInterface.class, "getSpeedInKnots"));
+        getRaceNameLengthValue = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(ExtendingInterface.class, "getRaceNameLength"));
+        getRegattaNameDimension = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(DataTypeWithContext.class, "getRegattaName"));
         
-        libraryFunction = FunctionFactory.createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(Test_ExternalLibraryClass.class, "foo"));
+        libraryFunction = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(FunctionTestsUtil.getMethodFromClass(Test_ExternalLibraryClass.class, "foo"));
     }
 
     @Test
@@ -43,5 +42,11 @@ public class TestDeclaringTypeOrParameterTypeCriteria {
 
         assertThat(criteria.matches(libraryFunction), is(false));
     }
+    
+    @Test
+    public void testGetElementType() {
+        FilterCriterion<Function<?>> criteria = new IsDeclaringTypeFilterCriterion(DataTypeWithContextImpl.class);
+        assertThat(criteria.getElementType().equals(Function.class), is(true));
+    }
 
 }

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/functions/criterias/TestMethodFilterCriterias.java

@@ -10,7 +10,7 @@ import org.junit.Test;
 import com.sap.sse.datamining.components.FilterCriterion;
 import com.sap.sse.datamining.test.util.FunctionTestsUtil;
 
-public class TestFunctionFilterCriterias {
+public class TestMethodFilterCriterias {
 
     @Test
     public void testMethodIsCorrectDimensionFilterCriteria() {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/i18n/TestI18N.java

@@ -4,6 +4,7 @@ import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertThat;
 
 import java.util.Locale;
+import java.util.MissingResourceException;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -16,23 +17,23 @@ public class TestI18N {
     private static final String SIMPLE_TEST_MESSAGE_KEY = "SimpleTestMessage";
     private static final String TEST_MESSAGE_WITH_PARAMETERS = "TestMessageWithParameters";
     
-    private DataMiningStringMessages bundleManager;
+    private DataMiningStringMessages testStringMessages;
     
     @Before
     public void initializeBundleManager() {
-        bundleManager = TestsUtil.getTestStringMessages();
+        testStringMessages = TestsUtil.getTestStringMessages();
     }
 
     @Test
     public void testGettingASimpleMessage() {
-        assertThat(bundleManager.get(Locale.ENGLISH, SIMPLE_TEST_MESSAGE_KEY), is("English"));
-        assertThat(bundleManager.get(Locale.GERMAN, SIMPLE_TEST_MESSAGE_KEY), is("Deutsch"));
+        assertThat(testStringMessages.get(Locale.ENGLISH, SIMPLE_TEST_MESSAGE_KEY), is("English"));
+        assertThat(testStringMessages.get(Locale.GERMAN, SIMPLE_TEST_MESSAGE_KEY), is("Deutsch"));
     }
     
     @Test
     public void testGettingAMessageWithParameters() {
-        assertThat(bundleManager.get(Locale.ENGLISH, TEST_MESSAGE_WITH_PARAMETERS, "Param0", "Param1"), is("English Param0 - Param1"));
-        assertThat(bundleManager.get(Locale.GERMAN, TEST_MESSAGE_WITH_PARAMETERS, "Param0", "Param1"), is("Deutsch Param0 - Param1"));
+        assertThat(testStringMessages.get(Locale.ENGLISH, TEST_MESSAGE_WITH_PARAMETERS, "Param0", "Param1"), is("English Param0 - Param1"));
+        assertThat(testStringMessages.get(Locale.GERMAN, TEST_MESSAGE_WITH_PARAMETERS, "Param0", "Param1"), is("Deutsch Param0 - Param1"));
     }
     
     @Test
@@ -43,5 +44,15 @@ public class TestI18N {
 
         assertThat(DataMiningStringMessages.Util.getLocaleFor("Unsupported locale info name"), is(Locale.ENGLISH));
     }
+    
+    @Test(expected=MissingResourceException.class)
+    public void testGettingAMessageForAMissingKeyFromSimpleStringMessages() {
+        testStringMessages.get(Locale.ENGLISH, "$%&MissingKey/()");
+    }
+    
+    @Test(expected=MissingResourceException.class)
+    public void testGettingAMessageForAMissingKeyFromCompoundStringMessages() {
+        TestsUtil.getTestStringMessagesWithProductiveMessages().get(Locale.ENGLISH, "$%&MissingKey/()");
+    }
 
 }

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/functions/registry/test_contexts/Test_HasLegOfCompetitorContext.java

@@ -5,7 +5,7 @@ import com.sap.sse.datamining.shared.annotations.Dimension;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Competitor;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Leg;
 
-public interface Test_HasLegContext extends Test_HasRaceContext {
+public interface Test_HasLegOfCompetitorContext extends Test_HasRaceContext {
     
     @Connector
     public Test_Leg getLeg();

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/functions/registry/test_contexts/Test_HasLegOfCompetitorContextImpl.java

@@ -6,13 +6,13 @@ import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Leg;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Race;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Regatta;
 
-public class Test_HasLegContextImpl extends Test_HasRaceContextImpl implements Test_HasLegContext {
+public class Test_HasLegOfCompetitorContextImpl extends Test_HasRaceContextImpl implements Test_HasLegOfCompetitorContext {
 
     private Test_Leg leg;
     private int legNumber;
     private Test_Competitor competitor;
 
-    public Test_HasLegContextImpl(Test_Regatta regatta, Test_Race race, Test_BoatClass boatClass, int year,
+    public Test_HasLegOfCompetitorContextImpl(Test_Regatta regatta, Test_Race race, Test_BoatClass boatClass, int year,
             Test_Leg leg, int legNumber, Test_Competitor competitor) {
         super(regatta, race, boatClass, year);
         this.leg = leg;

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/functions/test_classes/DataTypeWithContextImpl.java

@@ -1,6 +1,7 @@
 package com.sap.sse.datamining.test.functions.test_classes;
 
-public class DataTypeWithContextImpl implements DataTypeWithContext, ExtendingInterface {
+//This class needs to extend SuperType to increase the test coverage
+public class DataTypeWithContextImpl extends SuperType implements DataTypeWithContext, ExtendingInterface {
 
     private String regattaName;
     private String raceName;

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/functions/test_classes/SuperType.java

@@ -0,0 +1,5 @@
+package com.sap.sse.datamining.test.functions.test_classes;
+
+public class SuperType {
+    
+}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/ComponentTestsUtil.java

@@ -0,0 +1,130 @@
+package com.sap.sse.datamining.test.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+import com.sap.sse.datamining.factories.ProcessorFactory;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Boat;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_BoatClass;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Competitor;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Leg;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Race;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Regatta;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Team;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_BoatClassImpl;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_BoatImpl;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_CompetitorImpl;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_LegImpl;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_RaceImpl;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_RegattaImpl;
+import com.sap.sse.datamining.test.functions.registry.test_classes.impl.Test_TeamImpl;
+
+public final class ComponentTestsUtil {
+    
+    private final static ProcessorFactory processorFactory = new ProcessorFactory(ConcurrencyTestsUtil.getExecutor());
+    
+    public static ProcessorFactory getProcessorFactory() {
+        return processorFactory;
+    }
+
+    /**
+     * Creates a collection of {@link Test_Regatta Test_Regattas} containing the two regattas
+     * <ul>
+     *  <li>KW 2014 49er
+     *    <ul>
+     *     <li>with the {@link Test_BoatClass} 49er</li>
+     *     <li>and 3 {@link Test_Race Test_Races} (Race 1-3)
+     *      <ul>
+     *       <li>with 5 {@link Test_Leg Test_Legs} (with a value 0.0 as distance traveled)</li>
+     *       <li>and the competitors
+     *        <ul>
+     *         <li>GER1 (49er Team 1)</li>
+     *         <li>GER2 (49er Team 2)</li>
+     *         <li>GER3 (49er Team 3)</li>
+     *         <li>GER4 (49er Team 4)</li>
+     *        </ul>
+     *       </li>
+     *      </ul>
+     *     </li>
+     *    </ul>
+     *  </li>
+     *  <li>KW 2014 505 (with the {@link Test_BoatClass} 505)
+     *    <ul>
+     *     <li>with the {@link Test_BoatClass} 505</li>
+     *     <li>and 2 {@link Test_Race Test_Races} (Race 1-2)
+     *      <ul>
+     *       <li>with 5 {@link Test_Leg Test_Legs} (with a value 0.0 as distance traveled)</li>
+     *       <li>and the competitors
+     *        <ul>
+     *         <li>ENG1 (505 Team 1)</li>
+     *         <li>ENG2 (505 Team 2)</li>
+     *         <li>ENG3 (505 Team 3)</li>
+     *        </ul>
+     *       </li>
+     *      </ul>
+     *     </li>
+     *    </ul></li>
+     * </ul>
+     * @return an example data source for testing
+     */
+    public static Collection<Test_Regatta> createExampleDataSource() {
+        //Initialize 49er competitors
+        Test_Team team1_49er = new Test_TeamImpl("49er Team 1");
+        Test_Boat boatGER1 = new Test_BoatImpl("GER1");
+        Test_Competitor competitor1_49er = new Test_CompetitorImpl(team1_49er, boatGER1);
+        
+        Test_Team team2_49er = new Test_TeamImpl("49er Team 2");
+        Test_Boat boatGER2 = new Test_BoatImpl("GER2");
+        Test_Competitor competitor2_49er = new Test_CompetitorImpl(team2_49er, boatGER2);
+        
+        Test_Team team3_49er = new Test_TeamImpl("49er Team 3");
+        Test_Boat boatGER3 = new Test_BoatImpl("GER3");
+        Test_Competitor competitor3_49er = new Test_CompetitorImpl(team3_49er, boatGER3);
+        
+        Test_Team team4_49er = new Test_TeamImpl("49er Team 4");
+        Test_Boat boatGER4 = new Test_BoatImpl("GER4");
+        Test_Competitor competitor4_49er = new Test_CompetitorImpl(team4_49er, boatGER4);
+        
+        Collection<Test_Competitor> competitors49er = Arrays.asList(competitor1_49er, competitor2_49er, competitor3_49er, competitor4_49er);
+
+        //Initialize 505 competitors
+        Test_Team team1_505 = new Test_TeamImpl("505 Team 1");
+        Test_Boat boatENG1 = new Test_BoatImpl("ENG1");
+        Test_Competitor competitor1_505 = new Test_CompetitorImpl(team1_505, boatENG1);
+        
+        Test_Team team2_505 = new Test_TeamImpl("505 Team 2");
+        Test_Boat boatENG2 = new Test_BoatImpl("ENG2");
+        Test_Competitor competitor2_505 = new Test_CompetitorImpl(team2_505, boatENG2);
+        
+        Test_Team team3_505 = new Test_TeamImpl("505 Team 3");
+        Test_Boat boatENG3 = new Test_BoatImpl("ENG3");
+        Test_Competitor competitor3_505 = new Test_CompetitorImpl(team3_505, boatENG3);
+        
+        Collection<Test_Competitor> competitors505 = Arrays.asList(competitor1_505, competitor2_505, competitor3_505);
+        
+        // Test_Leg has only the statistic distance traveled
+        // This test requires only the dimensions, so only one leg is necessary
+        Test_Leg leg = new Test_LegImpl(0.0);
+        Collection<Test_Leg> legs = Arrays.asList(leg, leg, leg, leg, leg);
+        
+        //Initialize races, boat classes and regattas
+        Test_Race race1_49er = new Test_RaceImpl("Race 1", competitors49er, legs);
+        Test_Race race2_49er = new Test_RaceImpl("Race 2", competitors49er, legs);
+        Test_Race race3_49er = new Test_RaceImpl("Race 3", competitors49er, legs);
+        Test_Race race1_505 = new Test_RaceImpl("Race 1", competitors505, legs);
+        Test_Race race2_505 = new Test_RaceImpl("Race 2", competitors505, legs);
+
+        Test_BoatClass boatClass49er = new Test_BoatClassImpl("49er");
+        Test_BoatClass boatClass505 = new Test_BoatClassImpl("505");
+        
+        Test_Regatta regatta49er = new Test_RegattaImpl("KW 2014 49er", boatClass49er, 2014, race1_49er, race2_49er, race3_49er);
+        Test_Regatta regatta505 = new Test_RegattaImpl("KW 2014 505", boatClass505, 2014, race1_505, race2_505);
+        
+        Collection<Test_Regatta> dataSource = new ArrayList<>();
+        dataSource.add(regatta49er);
+        dataSource.add(regatta505);
+        return dataSource;
+    }
+    
+}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/ConcurrencyTestsUtil.java

@@ -39,7 +39,7 @@ public class ConcurrencyTestsUtil extends TestsUtil {
         }
     }
 
-    public static <T> void processElements(Processor<T> processor, Collection<T> elements) {
+    public static <T> void processElements(Processor<T, ?> processor, Collection<T> elements) {
         for (T element : elements) {
             processor.processElement(element);
         }
@@ -56,7 +56,7 @@ public class ConcurrencyTestsUtil extends TestsUtil {
         }
     }
 
-    public static void tryToFinishTheProcessorInAnotherThread(final Processor<?> processor) {
+    public static void tryToFinishTheProcessorInAnotherThread(final Processor<?, ?> processor) {
         Runnable finishingRunnable = new Runnable() {
             @Override
             public void run() {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/ExpectedFunctionRegistryUtil.java

@@ -8,13 +8,12 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Set;
 
-import com.sap.sse.datamining.factories.FunctionFactory;
 import com.sap.sse.datamining.functions.Function;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Boat;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Competitor;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Leg;
 import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Named;
-import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegContext;
+import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasLegOfCompetitorContext;
 import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContext;
 import com.sap.sse.datamining.test.functions.test_classes.Test_ExternalLibraryClass;
 
@@ -40,38 +39,38 @@ public class ExpectedFunctionRegistryUtil {
 
     private void buildExpectedDimensions() throws NoSuchMethodException, SecurityException {
         Method getNameMethod = Test_Named.class.getMethod("getName", new Class<?>[0]);
-        Function<?> getName = FunctionFactory.createMethodWrappingFunction(getNameMethod);
+        Function<?> getName = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getNameMethod);
         
         Method getRegattaMethod = Test_HasRaceContext.class.getMethod("getRegatta", new Class<?>[0]);
-        Function<?> getRegatta = FunctionFactory.createMethodWrappingFunction(getRegattaMethod);
-        addExpectedDimension(FunctionFactory.createCompoundFunction(null, Arrays.asList(getRegatta, getName)));
+        Function<?> getRegatta = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getRegattaMethod);
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getRegatta, getName)));
 
         Method getRaceMethod = Test_HasRaceContext.class.getMethod("getRace", new Class<?>[0]);
-        Function<?> getRace = FunctionFactory.createMethodWrappingFunction(getRaceMethod);
-        addExpectedDimension(FunctionFactory.createCompoundFunction(null, Arrays.asList(getRace, getName)));
+        Function<?> getRace = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getRaceMethod);
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getRace, getName)));
         
         Method getBoatClassMethod = Test_HasRaceContext.class.getMethod("getBoatClass", new Class<?>[0]);
-        Function<?> getBoatClass = FunctionFactory.createMethodWrappingFunction(getBoatClassMethod);
-        addExpectedDimension(FunctionFactory.createCompoundFunction(null, Arrays.asList(getBoatClass, getName)));
+        Function<?> getBoatClass = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getBoatClassMethod);
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getBoatClass, getName)));
         
         Method getYearMethod = Test_HasRaceContext.class.getMethod("getYear", new Class<?>[0]);
-        addExpectedDimension(FunctionFactory.createMethodWrappingFunction(getYearMethod));
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getYearMethod));
         
-        Method getLegNumberMethod = Test_HasLegContext.class.getMethod("getLegNumber", new Class<?>[0]);
-        addExpectedDimension(FunctionFactory.createMethodWrappingFunction(getLegNumberMethod));
+        Method getLegNumberMethod = Test_HasLegOfCompetitorContext.class.getMethod("getLegNumber", new Class<?>[0]);
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getLegNumberMethod));
         
-        Method getCompetitorMethod = Test_HasLegContext.class.getMethod("getCompetitor", new Class<?>[0]);
-        Function<?> getCompetitor = FunctionFactory.createMethodWrappingFunction(getCompetitorMethod);
+        Method getCompetitorMethod = Test_HasLegOfCompetitorContext.class.getMethod("getCompetitor", new Class<?>[0]);
+        Function<?> getCompetitor = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getCompetitorMethod);
         
         Method getTeamMethod = Test_Competitor.class.getMethod("getTeam", new Class<?>[0]);
-        Function<?> getTeam = FunctionFactory.createMethodWrappingFunction(getTeamMethod);
-        addExpectedDimension(FunctionFactory.createCompoundFunction(null, Arrays.asList(getCompetitor, getTeam, getName)));
+        Function<?> getTeam = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getTeamMethod);
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getCompetitor, getTeam, getName)));
         
         Method getBoatMethod = Test_Competitor.class.getMethod("getBoat", new Class<?>[0]);
-        Function<?> getBoat = FunctionFactory.createMethodWrappingFunction(getBoatMethod);
+        Function<?> getBoat = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getBoatMethod);
         Method getSailIDMethod = Test_Boat.class.getMethod("getSailID", new Class<?>[0]);
-        Function<?> getSailID = FunctionFactory.createMethodWrappingFunction(getSailIDMethod);
-        addExpectedDimension(FunctionFactory.createCompoundFunction(null, Arrays.asList(getCompetitor, getBoat, getSailID)));
+        Function<?> getSailID = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getSailIDMethod);
+        addExpectedDimension(FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getCompetitor, getBoat, getSailID)));
     }
     
     private void addExpectedDimension(Function<?> dimension) {
@@ -83,11 +82,11 @@ public class ExpectedFunctionRegistryUtil {
     }
 
     private void buildExpectedStatistics() throws NoSuchMethodException, SecurityException {
-        Method getLegMethod = Test_HasLegContext.class.getMethod("getLeg", new Class<?>[0]);
-        Function<?> getLeg = FunctionFactory.createMethodWrappingFunction(getLegMethod);
+        Method getLegMethod = Test_HasLegOfCompetitorContext.class.getMethod("getLeg", new Class<?>[0]);
+        Function<?> getLeg = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getLegMethod);
         Method getDistanceTraveledMethod = Test_Leg.class.getMethod("getDistanceTraveled", new Class<?>[0]);
-        Function<?> getDistanceTraveled = FunctionFactory.createMethodWrappingFunction(getDistanceTraveledMethod);
-        addExpectedStatistic(FunctionFactory.createCompoundFunction(null, Arrays.asList(getLeg, getDistanceTraveled)));
+        Function<?> getDistanceTraveled = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(getDistanceTraveledMethod);
+        addExpectedStatistic(FunctionTestsUtil.getFunctionFactory().createCompoundFunction(null, Arrays.asList(getLeg, getDistanceTraveled)));
     }
     
     private void addExpectedStatistic(Function<?> statistic) {
@@ -100,7 +99,7 @@ public class ExpectedFunctionRegistryUtil {
 
     private void buildExpectedExternalFunctions() throws NoSuchMethodException, SecurityException {
         Method fooMethod = Test_ExternalLibraryClass.class.getMethod("foo", new Class<?>[0]);
-        Function<?> foo = FunctionFactory.createMethodWrappingFunction(fooMethod);
+        Function<?> foo = FunctionTestsUtil.getFunctionFactory().createMethodWrappingFunction(fooMethod);
         addExpectedExternalFunction(foo);
     }
     

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/FunctionTestsUtil.java

@@ -7,6 +7,7 @@ import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
+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.test.functions.test_classes.DataTypeInterface;
@@ -17,11 +18,22 @@ import com.sap.sse.datamining.test.functions.test_classes.SimpleClassWithMarkedM
 import com.sap.sse.datamining.test.functions.test_classes.Test_ExternalLibraryClass;
 
 public class FunctionTestsUtil extends ConcurrencyTestsUtil {
+
+    private static final FunctionFactory functionFactory = new FunctionFactory();
+    private static final FunctionDTOFactory functionDTOFactory = new FunctionDTOFactory();
     
+    public static FunctionFactory getFunctionFactory() {
+        return functionFactory;
+    }
+    
+    public static FunctionDTOFactory getFunctionDTOFactory() {
+        return functionDTOFactory;
+    }
+
     public static Collection<Function<?>> getMarkedMethodsOfSimpleClassWithMarkedMethod() {
         Set<Function<?>> markedMethods = new HashSet<>();
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromSimpleClassWithMarkedMethod("dimension")));
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromSimpleClassWithMarkedMethod("sideEffectFreeValue")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromSimpleClassWithMarkedMethod("dimension")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromSimpleClassWithMarkedMethod("sideEffectFreeValue")));
         return markedMethods;
     }
     
@@ -31,7 +43,7 @@ public class FunctionTestsUtil extends ConcurrencyTestsUtil {
 
     public static Collection<Function<?>> getMethodsOfExternalLibraryClass() {
         Set<Function<?>> markedMethods = new HashSet<>();
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromExternalLibraryClass("foo")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromExternalLibraryClass("foo")));
         return markedMethods;
     }
 
@@ -41,16 +53,16 @@ public class FunctionTestsUtil extends ConcurrencyTestsUtil {
 
     public static Collection<Function<?>> getMarkedMethodsOfDataTypeWithContextImplAndItsSupertypes() {
         Collection<Function<?>> markedMethods = getMarkedMethodsOfDataTypeWithContextAndItsSupertypes();
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(ExtendingInterface.class, "getRaceNameLength")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(ExtendingInterface.class, "getRaceNameLength")));
         return markedMethods;
     }
 
     public static Collection<Function<?>> getMarkedMethodsOfDataTypeWithContextAndItsSupertypes() {
         Collection<Function<?>> markedMethods = new HashSet<>();
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeInterface.class, "getSpeedInKnots")));
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRegattaName")));
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRaceName")));
-        markedMethods.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getLegNumber")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeInterface.class, "getSpeedInKnots")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRegattaName")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRaceName")));
+        markedMethods.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getLegNumber")));
         return markedMethods;
     }
     
@@ -80,15 +92,15 @@ public class FunctionTestsUtil extends ConcurrencyTestsUtil {
 
     private static Collection<Function<?>> getDimensionsForSimpleClassWithMarkedMethods() {
         Collection<Function<?>> dimensions = new HashSet<>();
-        dimensions.add(FunctionFactory.createMethodWrappingFunction(getMethodFromSimpleClassWithMarkedMethod("dimension")));
+        dimensions.add(functionFactory.createMethodWrappingFunction(getMethodFromSimpleClassWithMarkedMethod("dimension")));
         return dimensions;
     }
 
     private static Collection<Function<?>> getDimensionsForDataTypeWithContext() {
         Collection<Function<?>> dimensions = new HashSet<>();
-        dimensions.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRegattaName")));
-        dimensions.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRaceName")));
-        dimensions.add(FunctionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getLegNumber")));
+        dimensions.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRegattaName")));
+        dimensions.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getRaceName")));
+        dimensions.add(functionFactory.createMethodWrappingFunction(getMethodFromClass(DataTypeWithContext.class, "getLegNumber")));
         return dimensions;
     }
     

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/StringRegexFilterCriterion.java

@@ -5,7 +5,7 @@ import com.sap.sse.datamining.impl.criterias.RegexFilterCriterion;
 public class StringRegexFilterCriterion extends RegexFilterCriterion<String> {
 
     public StringRegexFilterCriterion(String regex) {
-        super(regex);
+        super(String.class, regex);
     }
 
     @Override

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/TestsUtil.java

@@ -6,8 +6,10 @@ public class TestsUtil {
     
     private static final String TEST_STRING_MESSAGES_BASE_NAME = "stringmessages/Test_StringMessages";
     private static final DataMiningStringMessages TEST_STRING_MESSAGES = DataMiningStringMessages.Util.getInstanceFor(TEST_STRING_MESSAGES_BASE_NAME);
+
+    private static final String PRODUCTIVE_STRING_MESSAGES_BASE_NAME = "stringmessages/StringMessages";
     private static final DataMiningStringMessages EXTENDED_STRING_MESSAGES = DataMiningStringMessages.Util.getCompoundStringMessages(
-                                                                                DataMiningStringMessages.Util.getDefaultStringMessagesBaseName(),
+                                                                                PRODUCTIVE_STRING_MESSAGES_BASE_NAME,
                                                                                 TEST_STRING_MESSAGES_BASE_NAME);
     
     public static DataMiningStringMessages getTestStringMessages() {

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/BlockingInstructionWrapper.java

@@ -1,4 +1,4 @@
-package com.sap.sse.datamining.test.components.util;
+package com.sap.sse.datamining.test.util.components;
 
 import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil;
 

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/BlockingProcessor.java

@@ -1,4 +1,4 @@
-package com.sap.sse.datamining.test.components.util;
+package com.sap.sse.datamining.test.util.components;
 
 import java.util.Collection;
 import java.util.concurrent.Callable;
@@ -11,8 +11,10 @@ import com.sap.sse.datamining.impl.components.AbstractSimpleParallelProcessor;
 public class BlockingProcessor<InputType, ResultType> extends AbstractSimpleParallelProcessor<InputType, ResultType> {
     private final long timeToBlockInMillis;
 
-    public BlockingProcessor(ExecutorService executor, Collection<Processor<ResultType>> resultReceivers, long timeToBlockInMillis) {
-        super(executor, resultReceivers);
+    public BlockingProcessor(Class<InputType> inputType, Class<ResultType> resultType,
+                             ExecutorService executor, Collection<Processor<ResultType, ?>> resultReceivers,
+                             long timeToBlockInMillis) {
+        super(inputType, resultType, executor, resultReceivers);
         this.timeToBlockInMillis = timeToBlockInMillis;
     }
 

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/NullProcessor.java

@@ -0,0 +1,37 @@
+package com.sap.sse.datamining.test.util.components;
+
+import com.sap.sse.datamining.AdditionalResultDataBuilder;
+import com.sap.sse.datamining.impl.components.AbstractProcessor;
+
+public class NullProcessor<InputType, ResultType> extends AbstractProcessor<InputType, ResultType> {
+
+    public NullProcessor(Class<InputType> inputType, Class<ResultType> resultType) {
+        super(inputType, resultType);
+    }
+
+    @Override
+    public void processElement(InputType element) {
+
+    }
+
+    @Override
+    public void onFailure(Throwable failure) {
+
+    }
+
+    @Override
+    public void finish() throws InterruptedException {
+
+    }
+
+    @Override
+    public void abort() {
+
+    }
+
+    @Override
+    public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) {
+        return additionalDataBuilder;
+    }
+
+}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/Number.java

@@ -1,4 +1,4 @@
-package com.sap.sse.datamining.test.components.util;
+package com.sap.sse.datamining.test.util.components;
 
 import com.sap.sse.datamining.shared.annotations.Dimension;
 

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/TestLegOfCompetitorWithContextRetrievalProcessor.java

@@ -0,0 +1,36 @@
+package com.sap.sse.datamining.test.util.components;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.ExecutorService;
+
+import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Competitor;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Leg;
+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;
+
+public class TestLegOfCompetitorWithContextRetrievalProcessor extends
+        AbstractSimpleRetrievalProcessor<Test_HasRaceContext, Test_HasLegOfCompetitorContext>{
+
+    public TestLegOfCompetitorWithContextRetrievalProcessor(ExecutorService executor, Collection<Processor<Test_HasLegOfCompetitorContext, ?>> resultReceivers) {
+        super(Test_HasRaceContext.class, Test_HasLegOfCompetitorContext.class, executor, resultReceivers);
+    }
+
+    @Override
+    protected Iterable<Test_HasLegOfCompetitorContext> retrieveData(Test_HasRaceContext raceWithContext) {
+        Collection<Test_HasLegOfCompetitorContext> legsWithContext = new ArrayList<>();
+        int legNumber = 0;
+        for (Test_Leg leg : raceWithContext.getRace().getLegs()) {
+            legNumber++;
+            for (Test_Competitor competitor : raceWithContext.getRace().getCompetitors()) {
+                legsWithContext.add(new Test_HasLegOfCompetitorContextImpl(raceWithContext.getRegatta(), raceWithContext.getRace(), raceWithContext.getBoatClass(),
+                                                               raceWithContext.getYear(), leg, legNumber, competitor));
+            }
+        }
+        return legsWithContext;
+    }
+
+}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/TestRaceWithContextRetrievalProcessor.java

@@ -0,0 +1,31 @@
+package com.sap.sse.datamining.test.util.components;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.ExecutorService;
+
+import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Race;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Regatta;
+import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContext;
+import com.sap.sse.datamining.test.functions.registry.test_contexts.Test_HasRaceContextImpl;
+
+public class TestRaceWithContextRetrievalProcessor extends
+        AbstractSimpleRetrievalProcessor<Test_Regatta, Test_HasRaceContext> {
+
+    public TestRaceWithContextRetrievalProcessor(ExecutorService executor,
+            Collection<Processor<Test_HasRaceContext, ?>> resultReceivers) {
+        super(Test_Regatta.class, Test_HasRaceContext.class, executor, resultReceivers);
+    }
+
+    @Override
+    protected Iterable<Test_HasRaceContext> retrieveData(Test_Regatta regatta) {
+        Collection<Test_HasRaceContext> racesWithContext = new ArrayList<>();
+        for (Test_Race race : regatta.getRaces()) {
+            racesWithContext.add(new Test_HasRaceContextImpl(regatta, race, regatta.getBoatClass(), regatta.getYear()));
+        }
+        return racesWithContext;
+    }
+
+}

java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/test/util/components/TestRegattaRetrievalProcessor.java

@@ -0,0 +1,23 @@
+package com.sap.sse.datamining.test.util.components;
+
+import java.util.Collection;
+import java.util.concurrent.ExecutorService;
+
+import com.sap.sse.datamining.components.Processor;
+import com.sap.sse.datamining.impl.components.AbstractSimpleRetrievalProcessor;
+import com.sap.sse.datamining.test.functions.registry.test_classes.Test_Regatta;
+
+public class TestRegattaRetrievalProcessor extends
+        AbstractSimpleRetrievalProcessor<Collection<Test_Regatta>, Test_Regatta> {
+
+    @SuppressWarnings("unchecked")
+    public TestRegattaRetrievalProcessor(ExecutorService executor, Collection<Processor<Test_Regatta, ?>> resultReceivers) {
+        super((Class<Collection<Test_Regatta>>)(Class<?>) Collection.class, Test_Regatta.class, executor, resultReceivers);
+    }
+
+    @Override
+    protected Iterable<Test_Regatta> retrieveData(Collection<Test_Regatta> regattas) {
+        return regattas;
+    }
+
+}