Replaced the Futures with AsyncCallbacks

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

@@ -8,10 +8,6 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
@@ -108,7 +104,12 @@ class DimensionFilterSelectionProvider {
         public void onValueChange(ValueChangeEvent<FunctionDTO> event) {
             final FunctionDTO dimension = event.getValue();
             if (dimension != null) {
-                fetchAndDisplayAvailableData(false);
+                fetchAndDisplayAvailableData(false, new AsyncCallback<Boolean>() {
+                    @Override
+                    public void onFailure(Throwable caught) { }
+                    @Override
+                    public void onSuccess(Boolean result) { }
+                });
                 if (firstChange && retrieverLevelSelectionProvider.canAddDimensionSelectionProvider()) {
                     retrieverLevelSelectionProvider.createAndAddDimensionSelectionProvider();
                 }
@@ -134,12 +135,9 @@ class DimensionFilterSelectionProvider {
      * 
      * @param isUpdate <code>true</code>, if the call should update the data and preserve the selection and 
      *                 <code>false</code>, if it should override the data and clear the selection.
-     * @return A {@link Future}, that returns <code>true</code>, if the filter selection has been changed after 
-     *         the data has been set.
+     * @param selectionChangedCallback An {@link AsyncCallback} to react, if the selection has been changed or not.
      */
-    Future<Boolean> fetchAndDisplayAvailableData(final boolean isUpdate) {
-        final SelectionChangedFuture future = new SelectionChangedFuture();
-        
+    void fetchAndDisplayAvailableData(final boolean isUpdate, final AsyncCallback<Boolean> selectionChangedCallback) {
         final FunctionDTO dimension = getSelectedDimension();
         Collection<FunctionDTO> dimensionDTOs = new ArrayList<>();
         dimensionDTOs.add(dimension);
@@ -172,7 +170,6 @@ class DimensionFilterSelectionProvider {
                             } else {
                                 selectionChanged = selectionTable.setContent(content);
                             }
-                            future.set(selectionChanged);
                             
                             if (selectionToBeApplied != null) {
                                 selectionTable.setSelection(selectionToBeApplied);
@@ -180,19 +177,19 @@ class DimensionFilterSelectionProvider {
                             }
                             selectionTable.setVisible(true);
                             toggleFilterButton.setVisible(true);
+                            
+                            selectionChangedCallback.onSuccess(selectionChanged);
                         }
                         
                         busyIndicator.setVisible(false);
                     }
                     @Override
                     public void onFailure(Throwable caught) {
-                        future.cancel(false);
                         errorReporter.reportError("Error fetching the dimension values of " + dimension + ": "
                                 + caught.getMessage());
+                        selectionChangedCallback.onFailure(caught);
                     }
                 });
-        
-        return future;
     }
     
     void setAvailableDimensions(Collection<FunctionDTO> availableDimensions) {
@@ -229,60 +226,4 @@ class DimensionFilterSelectionProvider {
         selectionTable.resizeTo(widthInPX, remainingHeightInPX);
     }
     
-    public static class SelectionChangedFuture implements Future<Boolean> {
-
-        private static final int SLEEP_TIME = 100;
-        
-        private boolean cancel;
-        private Boolean value = null;
-
-        @Override
-        public boolean cancel(boolean mayInterruptIfRunning) {
-            if (isDone()) {
-                return false;
-            }
-            
-            cancel = true;
-            return true;
-        }
-
-        @Override
-        public boolean isCancelled() {
-            return cancel;
-        }
-
-        @Override
-        public boolean isDone() {
-            return isCancelled() || value != null;
-        }
-        
-        private void set(Boolean value) {
-            this.value  = value;
-            
-        }
-
-        @Override
-        public Boolean get() throws InterruptedException, ExecutionException {
-            while (!isDone()) {
-                Thread.sleep(SLEEP_TIME);
-            }
-            return value;
-        }
-
-        @Override
-        public Boolean get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
-                TimeoutException {
-            long timeLeft = unit.toMillis(timeout);
-            while (!isDone()) {
-                Thread.sleep(SLEEP_TIME);
-                timeLeft -= SLEEP_TIME;
-                if (timeLeft <= 0) {
-                    throw new TimeoutException();
-                }
-            }
-            return value;
-        }
-        
-    }
-    
 }

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

@@ -216,28 +216,40 @@ public class ListRetrieverChainFilterSelectionProvider implements FilterSelectio
     }
     
     void retrieverLevelFilterSelectionChanged(RetrieverLevelFilterSelectionProvider retrieverLevelFilterSelectionProvider, DimensionFilterSelectionProvider dimensionFilterSelectionProvider) {
-        boolean selectionChanged = updateFilterSelectionProviders(retrieverLevelFilterSelectionProvider.getRetrieverLevel(), dimensionFilterSelectionProvider.getSelectedDimension());
-        if (!selectionChanged) {
+        updateFilterSelectionProviders(retrieverLevelFilterSelectionProvider.getRetrieverLevel(), dimensionFilterSelectionProvider.getSelectedDimension());
+    }
+    
+    private void updateFilterSelectionProviders(int beginningWithLevel, final FunctionDTO exceptForDimension) {
+        LocalizedTypeDTO retrievedDataType = null;
+        int nextRetrieverLevel = 0;
+        for (int retrieverLevel = beginningWithLevel; retrieverLevel < retrieverChain.size(); retrieverLevel++) {
+            retrievedDataType = retrieverChain.getRetrievedDataType(retrieverLevel);
+            if (selectionProvidersMappedByRetrievedDataType.containsKey(retrievedDataType)) {
+                nextRetrieverLevel = retrieverLevel + 1;
+                break;
+            }
+        }
+        final int finalNextRetrievalLevel = nextRetrieverLevel;
+        
+        if (retrievedDataType != null) {
+            selectionProvidersMappedByRetrievedDataType.get(retrievedDataType).updateAvailableData(exceptForDimension,
+                    new AsyncCallback<Boolean>() {
+                        @Override
+                        public void onFailure(Throwable caught) {
+                        }
+
+                        @Override
+                        public void onSuccess(Boolean selectionChanged) {
+                            if (selectionChanged != null && !selectionChanged) {
+                                updateFilterSelectionProviders(finalNextRetrievalLevel, exceptForDimension);
+                            }
+                        }
+                    });
+        } else {
             mainPanel.setWidgetHidden(selectionPresenterScrollPanel, getSelection().isEmpty());
             notifyListeners();
         }
     }
-    
-    private boolean updateFilterSelectionProviders(int beginningWithLevel, FunctionDTO exceptForDimension) {
-        boolean selectionChanged = false;
-        for (int retrieverLevel = beginningWithLevel; retrieverLevel < retrieverChain.size(); retrieverLevel++) {
-            final LocalizedTypeDTO retrievedDataType = retrieverChain.getRetrievedDataType(retrieverLevel);
-            if (selectionProvidersMappedByRetrievedDataType.containsKey(retrievedDataType)) {
-                boolean retrieverLevelSelectionChanged = selectionProvidersMappedByRetrievedDataType.get(retrievedDataType)
-                        .updateAvailableData(exceptForDimension);
-                if (retrieverLevelSelectionChanged) {
-                    selectionChanged = true;
-                    break;
-                }
-            }
-        }
-        return selectionChanged;
-    }
 
     @Override
     public Map<Integer, Map<FunctionDTO, Collection<? extends Serializable>>> getSelection() {

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

@@ -5,11 +5,11 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
 
+import com.google.gwt.user.client.rpc.AsyncCallback;
 import com.google.gwt.user.client.ui.HorizontalPanel;
 import com.google.gwt.user.client.ui.ProvidesResize;
 import com.google.gwt.user.client.ui.RequiresResize;
@@ -133,27 +133,35 @@ public class RetrieverLevelFilterSelectionProvider implements Component<Abstract
     /**
      * Updates the dimension values except for the given dimension.<br>
      * Aborts the update, if it caused a selection change.
-     * @return <code>true</code>, if the selection has been changed because of the update.
      */
-    boolean updateAvailableData(FunctionDTO exceptForDimension) {
-        boolean selectionChanged = false;
-        for (DimensionFilterSelectionProvider selectionProvider : dimensionSelectionProviders) {
+    void updateAvailableData(FunctionDTO exceptForDimension, AsyncCallback<Boolean> selectionChangedCallback) {
+        updateAvailableData(exceptForDimension, selectionChangedCallback, dimensionSelectionProviders.iterator());
+    }
+    
+    private void updateAvailableData(final FunctionDTO exceptForDimension, final AsyncCallback<Boolean> selectionChangedCallback, final Iterator<DimensionFilterSelectionProvider> selectionProviderIterator) {
+        if (selectionProviderIterator.hasNext()) {
+            DimensionFilterSelectionProvider selectionProvider = selectionProviderIterator.next();
             FunctionDTO selectedDimension = selectionProvider.getSelectedDimension();
             if (selectedDimension != null && !selectedDimension.equals(exceptForDimension)) {
-                Future<Boolean> dimensionSelectionChangedFuture = selectionProvider.fetchAndDisplayAvailableData(true);
-                Boolean dimensionsSelectionChanged = null;
-                try {
-                    dimensionsSelectionChanged = dimensionSelectionChangedFuture.get();
-                } catch (InterruptedException | ExecutionException e) {
-                    errorReporter.reportError("Error updating the available data: " + e);
-                } 
-                if (dimensionsSelectionChanged != null && dimensionsSelectionChanged) {
-                    selectionChanged = true;
-                    break;
-                }
+                selectionProvider.fetchAndDisplayAvailableData(true, new AsyncCallback<Boolean>() {
+                    @Override
+                    public void onFailure(Throwable caught) { }
+                    @Override
+                    public void onSuccess(Boolean selectionChanged) {
+                        if (selectionChanged != null && !selectionChanged) {
+                            updateAvailableData(exceptForDimension, selectionChangedCallback, selectionProviderIterator);
+                        } else {
+                            selectionChangedCallback.onSuccess(true);
+                        }
+                    }
+                    
+                });
+            } else {
+                updateAvailableData(exceptForDimension, selectionChangedCallback, selectionProviderIterator);
             }
+        } else {
+            selectionChangedCallback.onSuccess(false);
         }
-        return selectionChanged;
     }
 
     void dimensionFilterSelectionChanged(DimensionFilterSelectionProvider dimensionFilterSelectionProvider) {