Retrieval Processor can now have settings

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

@@ -1,8 +1,10 @@
 package com.sap.sse.datamining.impl.components;
 
+import static com.sap.sse.datamining.test.util.ConcurrencyTestsUtil.getExecutor;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.not;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
 
 import java.util.Collection;
 import java.util.List;
@@ -24,8 +26,10 @@ 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.TestNullRetrievalProcessorWithSettings;
 import com.sap.sse.datamining.test.util.components.TestRaceWithContextRetrievalProcessor;
 import com.sap.sse.datamining.test.util.components.TestRegattaRetrievalProcessor;
+import com.sap.sse.datamining.test.util.components.Test_NullRetrievalProcessorSettings;
 
 public class TestDataRetrieverChainCreation {
 
@@ -96,18 +100,27 @@ public class TestDataRetrieverChainCreation {
 
         try {
             chainBuilder.getCurrentRetrievedDataType();
+            fail("An IllegalStateException is expected.");
         } catch (IllegalStateException e) {
         }
         try {
             chainBuilder.setFilter(null);
+            fail("An IllegalStateException is expected.");
+        } catch (IllegalStateException e) {
+        }
+        try {
+            chainBuilder.setSettings(null);
+            fail("An IllegalStateException is expected.");
         } catch (IllegalStateException e) {
         }
         try {
             chainBuilder.addResultReceiver(null);
+            fail("An IllegalStateException is expected.");
         } catch (IllegalStateException e) {
         }
         try {
             chainBuilder.build();
+            fail("An IllegalStateException is expected.");
         } catch (IllegalStateException e) {
         }
     }
@@ -243,5 +256,55 @@ public class TestDataRetrieverChainCreation {
         
         dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor());
     }
+    
+    @Test(expected=IllegalStateException.class)
+    public void testSteppingToFar() {
+        DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor());
+        while (chainBuilder.canStepFurther()) {
+            chainBuilder.stepFurther();
+        }
+        chainBuilder.stepFurther();
+    }
+    
+    @Test
+    public void testRetrieverChainWithSettingsCreation() {
+        DataRetrieverChainDefinition<Collection<Test_Regatta>, Test_HasLegOfCompetitorContext> chainWithSettings = 
+                new SimpleDataRetrieverChainDefinition<>(dataRetrieverChainDefinition, Test_HasLegOfCompetitorContext.class, "TestRetrieverChain");
+        chainWithSettings.endWith(TestLegOfCompetitorWithContextRetrievalProcessor.class, TestNullRetrievalProcessorWithSettings.class, Test_HasLegOfCompetitorContext.class,
+                Test_NullRetrievalProcessorSettings.class, "legOfCompetitor");
+        
+        DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = chainWithSettings.startBuilding(getExecutor());
+        while (chainBuilder.canStepFurther()) {
+            chainBuilder.stepFurther();
+        }
+        
+        chainBuilder.build();
+        
+        Test_NullRetrievalProcessorSettings settings = new Test_NullRetrievalProcessorSettings("Settings Value");
+        chainBuilder.setSettings(settings);
+        
+        chainBuilder.build();
+    }
+    
+    @Test(expected=IllegalArgumentException.class)
+    public void testRetrieverChainWithWrongSettingsCreation() {
+        DataRetrieverChainDefinition<Collection<Test_Regatta>, Test_HasLegOfCompetitorContext> chainWithSettings = 
+                new SimpleDataRetrieverChainDefinition<>(dataRetrieverChainDefinition, Test_HasLegOfCompetitorContext.class, "TestRetrieverChain");
+        chainWithSettings.endWith(TestLegOfCompetitorWithContextRetrievalProcessor.class, TestNullRetrievalProcessorWithSettings.class, Test_HasLegOfCompetitorContext.class,
+                Test_NullRetrievalProcessorSettings.class, "legOfCompetitor");
+        
+        DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = chainWithSettings.startBuilding(getExecutor());
+        while (chainBuilder.canStepFurther()) {
+            chainBuilder.stepFurther();
+        }
+        chainBuilder.setSettings("Error");
+    }
+    
+    @Test(expected=IllegalStateException.class)
+    public void testRetrieverWithNoSettingsButSettedSettingsCreated() {
+        DataRetrieverChainBuilder<Collection<Test_Regatta>> chainBuilder = dataRetrieverChainDefinition.startBuilding(ConcurrencyTestsUtil.getExecutor());
+        chainBuilder.stepFurther(); // Initialization
+        chainBuilder.setSettings("Error");
+    }
 
 }

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

@@ -0,0 +1,29 @@
+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.AbstractRetrievalProcessor;
+import com.sap.sse.datamining.test.data.Test_HasLegOfCompetitorContext;
+
+public class TestNullRetrievalProcessorWithSettings extends AbstractRetrievalProcessor<Test_HasLegOfCompetitorContext, Test_HasLegOfCompetitorContext>{
+
+    @SuppressWarnings("unused")
+    private Test_NullRetrievalProcessorSettings settings;
+
+    public TestNullRetrievalProcessorWithSettings(ExecutorService executor, Collection<Processor<Test_HasLegOfCompetitorContext, ?>> resultReceivers,
+            Test_NullRetrievalProcessorSettings settings, int retrievalLevel) {
+        super(Test_HasLegOfCompetitorContext.class, Test_HasLegOfCompetitorContext.class, executor, resultReceivers, retrievalLevel);
+        this.settings = settings;
+    }
+
+    @Override
+    protected Iterable<Test_HasLegOfCompetitorContext> retrieveData(Test_HasLegOfCompetitorContext legWithContext) {
+        Collection<Test_HasLegOfCompetitorContext> legsWithContext = new ArrayList<>();
+        legsWithContext.add(legWithContext);
+        return legsWithContext;
+    }
+
+}

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

@@ -0,0 +1,15 @@
+package com.sap.sse.datamining.test.util.components;
+
+public class Test_NullRetrievalProcessorSettings {
+    
+    private final String value;
+
+    public Test_NullRetrievalProcessorSettings(String value) {
+        this.value = value;
+    }
+    
+    public String getValue() {
+        return value;
+    }
+
+}

java/com.sap.sse.datamining/src/com/sap/sse/datamining/components/DataRetrieverChainBuilder.java

@@ -49,6 +49,15 @@ public interface DataRetrieverChainBuilder<DataSourceType> {
      *         {@link #getCurrentRetrievedDataType() current retrieved data type}.
      */
     public DataRetrieverChainBuilder<DataSourceType> setFilter(FilterCriterion<?> filter);
+
+    /**
+     * Sets the settings for the data retriever of the current level.
+     * 
+     * @throws IllegalStateException if {@link #stepFurther()} has not yet been called.
+     * @throws IllegalArgumentException if the <code>SettingsType</code> isn't applicable for the
+     *         {@link DataRetrieverLevel#getSettingsType() settings of the current retriever level}.
+     */
+    public <SettingsType> DataRetrieverChainBuilder<DataSourceType> setSettings(SettingsType settings);
     
     /**
      * Adds a result receiver to the data retriever of the current level.

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/DataRetrieverLevel.java

@@ -45,7 +45,7 @@ public class DataRetrieverLevel<InputType, RetrievedDataType> {
     public String toString() {
         return "Level " + retrieverLevel + " [retrieverType: " + retrieverType.getSimpleName() 
                                          + ", retrievedDataType: " + retrievedDataType.getSimpleName()
-                                         + ", settingsType: " + settingsType.getSimpleName()
+                                         + ", settingsType: " + (settingsType == null ? "null" : settingsType.getSimpleName())
                                          + ", messageKey: " + retrievedDataTypeMessageKey + "]";
     }
 

java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/components/SimpleDataRetrieverChainBuilder.java

@@ -19,11 +19,12 @@ import com.sap.sse.datamining.components.Processor;
 public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetrieverChainBuilder<DataSourceType> {
     
     private final ExecutorService executor;
-    private final List<DataRetrieverLevel<?, ?>> dataRetrieverTypesWithInformation;
+    private final List<DataRetrieverLevel<?, ?>> retrieverLevels;
 
     private final Map<Integer, FilterCriterion<?>> filters;
     private final Map<Integer, Collection<Processor<?, ?>>> receivers;
-    private int currentRetrieverTypeIndex;
+    private final Map<Integer, Object> settings;
+    private int currentRetrieverLevelIndex;
 
     /**
      * Creates a data retriever chain builder for the given list of {@link DataRetrieverLevel}.</br>
@@ -44,16 +45,17 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
     SimpleDataRetrieverChainBuilder(ExecutorService executor,
             List<DataRetrieverLevel<?, ?>> dataRetrieverTypesWithInformation) {
         this.executor = executor;
-        this.dataRetrieverTypesWithInformation = new ArrayList<>(dataRetrieverTypesWithInformation);
+        this.retrieverLevels = new ArrayList<>(dataRetrieverTypesWithInformation);
         
         filters = new HashMap<>();
         receivers = new HashMap<>();
-        currentRetrieverTypeIndex = -1;
+        settings = new HashMap<>();
+        currentRetrieverLevelIndex = -1;
     }
     
     @Override
     public boolean canStepFurther() {
-        return currentRetrieverTypeIndex + 1 < dataRetrieverTypesWithInformation.size();
+        return currentRetrieverLevelIndex + 1 < retrieverLevels.size();
     }
 
     @Override
@@ -62,7 +64,7 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
             throw new IllegalStateException("The builder can't step any further");
         }
         
-        currentRetrieverTypeIndex++;
+        currentRetrieverLevelIndex++;
         return this;
     }
 
@@ -77,7 +79,26 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
                                                + "') isn't able to match the current retrieved data type '" + getCurrentRetrievedDataType().getSimpleName() + "'");
         }
 
-        filters.put(currentRetrieverTypeIndex, filter);
+        filters.put(currentRetrieverLevelIndex, filter);
+        return this;
+    }
+    
+    @Override
+    public <SettingsType> DataRetrieverChainBuilder<DataSourceType> setSettings(SettingsType settings) {
+        if (!hasBeenInitialized()) {
+            throw new IllegalStateException("The builder hasn't been initialized");
+        }
+        if (getCurrentRetrieverLevel().getSettingsType() == null) {
+            throw new IllegalStateException("The current retrieval level " + getCurrentRetrieverLevel() + " has no settings.");
+        }
+        
+        if (!getCurrentRetrieverLevel().getSettingsType().isAssignableFrom(settings.getClass())) {
+            throw new IllegalArgumentException("The given settings (with type '" + settings.getClass().getSimpleName()
+                    + "') isn't applicable for the settings type of the current retriever Level '"
+                    + getCurrentRetrieverLevel().getSettingsType().getSimpleName() + "'");
+        }
+        
+        this.settings.put(currentRetrieverLevelIndex, settings);
         return this;
     }
 
@@ -92,10 +113,10 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
                     + "') isn't able to process the current retrieved data type '" + getCurrentRetrievedDataType().getSimpleName() + "'");
         }
 
-        if (!receivers.containsKey(currentRetrieverTypeIndex)) {
-            receivers.put(currentRetrieverTypeIndex, new HashSet<Processor<?, ?>>());
+        if (!receivers.containsKey(currentRetrieverLevelIndex)) {
+            receivers.put(currentRetrieverLevelIndex, new HashSet<Processor<?, ?>>());
         }
-        receivers.get(currentRetrieverTypeIndex).add(resultReceiver);
+        receivers.get(currentRetrieverLevelIndex).add(resultReceiver);
         return this;
     }
 
@@ -105,12 +126,12 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
             throw new IllegalStateException("The builder hasn't been initialized");
         }
         
-        return dataRetrieverTypesWithInformation.get(currentRetrieverTypeIndex).getRetrievedDataType();
+        return retrieverLevels.get(currentRetrieverLevelIndex).getRetrievedDataType();
     }
     
     @Override
     public DataRetrieverLevel<?, ?> getCurrentRetrieverLevel() {
-        return hasBeenInitialized() ? dataRetrieverTypesWithInformation.get(currentRetrieverTypeIndex) : null;
+        return hasBeenInitialized() ? retrieverLevels.get(currentRetrieverLevelIndex) : null;
     }
 
     @SuppressWarnings("unchecked")
@@ -121,37 +142,37 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
         }
         
         Processor<?, ?> firstRetriever = null;
-        for (int retrieverTypeIndex = currentRetrieverTypeIndex; retrieverTypeIndex >= 0; retrieverTypeIndex--) {
-            DataRetrieverLevel<?, ?> dataRetrieverTypeWithInformation = dataRetrieverTypesWithInformation.get(retrieverTypeIndex);
-            firstRetriever = createRetriever(dataRetrieverTypeWithInformation, firstRetriever, retrieverTypeIndex);
+        for (int retrieverLevelIndex = currentRetrieverLevelIndex; retrieverLevelIndex >= 0; retrieverLevelIndex--) {
+            DataRetrieverLevel<?, ?> retrieverLevel = retrieverLevels.get(retrieverLevelIndex);
+            firstRetriever = createRetriever(retrieverLevel, firstRetriever, retrieverLevelIndex);
         }
         
         return (Processor<DataSourceType, ?>) firstRetriever;
     }
 
     public boolean hasBeenInitialized() {
-        return currentRetrieverTypeIndex >= 0;
+        return currentRetrieverLevelIndex >= 0;
     }
     
     @SuppressWarnings("unchecked")
-    private <ResultType> Processor<?, ResultType> createRetriever(DataRetrieverLevel<?, ?> dataRetrieverTypeWithInformation, Processor<?, ?> previousRetriever, int retrieverTypeIndex) {
-        Class<ResultType> retrievedDataType = (Class<ResultType>) dataRetrieverTypeWithInformation.getRetrievedDataType();
+    private <ResultType> Processor<?, ResultType> createRetriever(DataRetrieverLevel<?, ?> retrieverLevel, Processor<?, ?> previousRetriever, int retrieverLevelIndex) {
+        Class<ResultType> retrievedDataType = (Class<ResultType>) retrieverLevel.getRetrievedDataType();
         
-        Collection<?> storedResultReceivers = receivers.get(retrieverTypeIndex);
+        Collection<?> storedResultReceivers = receivers.get(retrieverLevelIndex);
         Collection<Processor<ResultType, ?>> resultReceivers = storedResultReceivers != null ? new ArrayList<Processor<ResultType, ?>>((Collection<Processor<ResultType, ?>>) storedResultReceivers) : new ArrayList<Processor<ResultType, ?>>();
         if (previousRetriever != null) {
             resultReceivers.add((Processor<ResultType, ?>) previousRetriever);
         }
         
-        FilterCriterion<ResultType> filter = (FilterCriterion<ResultType>) filters.get(retrieverTypeIndex);
+        FilterCriterion<ResultType> filter = (FilterCriterion<ResultType>) filters.get(retrieverLevelIndex);
         
-        Class<Processor<?, ResultType>> retrieverType = (Class<Processor<?, ResultType>>)(Class<?>) dataRetrieverTypeWithInformation.getRetrieverType();
-        Class<?> settingsType = dataRetrieverTypeWithInformation.getSettingsType();
-        return createRetriever(retrieverType, retrievedDataType, resultReceivers, filter, settingsType, retrieverTypeIndex);
+        Class<Processor<?, ResultType>> retrieverType = (Class<Processor<?, ResultType>>)(Class<?>) retrieverLevel.getRetrieverType();
+        Class<?> settingsType = retrieverLevel.getSettingsType();
+        return createRetriever(retrieverType, retrievedDataType, resultReceivers, filter, settingsType, retrieverLevelIndex);
     }
 
     private <ResultType> Processor<?, ResultType> createRetriever(Class<Processor<?, ResultType>> retrieverType, Class<ResultType> retrievedDataType,
-            Collection<Processor<ResultType, ?>> resultReceivers, FilterCriterion<ResultType> filter, Class<?> settingsType, int retrieverTypeIndex) {
+            Collection<Processor<ResultType, ?>> resultReceivers, FilterCriterion<ResultType> filter, Class<?> settingsType, int retrieverLevelIndex) {
         Constructor<Processor<?, ResultType>> retrieverConstructor = null;
         try {
             if (settingsType == null) {
@@ -166,13 +187,13 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
         
         Object settings = null;
         if (settingsType != null) {
-            // TODO Get Settings for retriever.
+            this.settings.get(retrieverLevelIndex);
         }
-        return constructRetriever(retrieverConstructor, retrievedDataType, resultReceivers, filter, settings, retrieverTypeIndex);
+        return constructRetriever(retrieverConstructor, retrievedDataType, resultReceivers, filter, settings, settingsType, retrieverLevelIndex);
     }
 
     private <ResultType> Processor<?, ResultType> constructRetriever(Constructor<Processor<?, ResultType>> retrieverConstructor, Class<ResultType> retrievedDataType,
-            Collection<Processor<ResultType, ?>> resultReceivers, FilterCriterion<ResultType> filter, Object settings, int retrieverTypeIndex) {
+            Collection<Processor<ResultType, ?>> resultReceivers, FilterCriterion<ResultType> filter, Object settings, Class<?> settingsType, int retrieverLevelIndex) {
         try {
             Collection<Processor<ResultType, ?>> retrievalResultReceivers = resultReceivers;
             if (filter != null) {
@@ -188,10 +209,10 @@ public class SimpleDataRetrieverChainBuilder<DataSourceType> implements DataRetr
                 retrieverConstructor.setAccessible(true);
             }
             
-            if (settings == null) {
-                return retrieverConstructor.newInstance(executor, retrievalResultReceivers, retrieverTypeIndex);
+            if (settingsType == null) {
+                return retrieverConstructor.newInstance(executor, retrievalResultReceivers, retrieverLevelIndex);
             } else {
-                return retrieverConstructor.newInstance(executor, retrievalResultReceivers, settings, retrieverTypeIndex);
+                return retrieverConstructor.newInstance(executor, retrievalResultReceivers, settings, retrieverLevelIndex);
             }
         } catch (InstantiationException | IllegalAccessException |
                  IllegalArgumentException | InvocationTargetException e) {