SCL expressions to SCL Issues view

[simantics/platform.git] / bundles / org.simantics.scl.ui / src / org / simantics / scl / ui / issues / SCLIssuesContentProvider.java

diff --git a/bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/issues/SCLIssuesContentProvider.java b/bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/issues/SCLIssuesContentProvider.java
index 4772ad5ba7996b89baa875c4cf24db9e70e940e4..4e386e685b3c168bfdec4c47189a9fae8bea100f 100644 (file)
--- a/bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/issues/SCLIssuesContentProvider.java
+++ b/bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/issues/SCLIssuesContentProvider.java
@@ -1,90 +1,40 @@
 package org.simantics.scl.ui.issues;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
 
 import org.eclipse.jface.viewers.IStructuredContentProvider;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.swt.widgets.Control;
-import org.simantics.scl.compiler.errors.CompilationError;
-import org.simantics.scl.compiler.errors.DoesNotExist;
-import org.simantics.scl.compiler.errors.Failable;
-import org.simantics.scl.compiler.errors.Failure;
-import org.simantics.scl.compiler.module.Module;
-import org.simantics.scl.compiler.module.repository.ModuleRepository;
-import org.simantics.scl.compiler.module.repository.UpdateListener;
-
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.procedure.TObjectObjectProcedure;
-import gnu.trove.procedure.TObjectProcedure;
+import org.simantics.scl.osgi.issues.SCLIssueFactoryProvider;
+import org.simantics.scl.osgi.issues.SCLIssueProviderFactory.SCLIssueProvider;
+import org.simantics.scl.osgi.issues.SCLIssuesTableEntry;
 
 public class SCLIssuesContentProvider implements IStructuredContentProvider {
 
     public static final int MAX_ISSUE_COUNT = 1000;
-    
-    Viewer viewer;
-    ModuleRepository repository;
+
+    private Viewer viewer;
     boolean disposed = false;
-    AtomicBoolean refreshInProgress = new AtomicBoolean(false);
-    
-    THashMap<String, CompilationError[]> currentFailures = new THashMap<String, CompilationError[]>();
-    THashMap<String, UpdateListener> updateListeners = new THashMap<String, UpdateListener>(); 
-    
+    private AtomicBoolean refreshInProgress = new AtomicBoolean(false);
+    private List<SCLIssueProvider> issueProviders = new ArrayList<>();
+
     @Override
     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
         this.viewer = viewer;
-        this.repository = (ModuleRepository)newInput;
-        if(newInput != null)
-            listenIssues();
-    }
-    
-    private UpdateListener getUpdateListener(String moduleName) {
-        UpdateListener listener;
-        synchronized(updateListeners) {
-            listener = updateListeners.get(moduleName);
-            if(listener == null) {
-                listener = new UpdateListener() {
-                    @Override
-                    public void notifyAboutUpdate() {
-                        if(!disposed)
-                            listenModule(moduleName);
-                    }
-                };
-                updateListeners.put(moduleName, listener);
-            }
+        if (!issueProviders.isEmpty()) {
+            issueProviders.forEach(p -> p.dispose());
+            issueProviders.clear();
         }
-        return listener;
-    }
-    
-    private void listenModule(String moduleName) {
-        if(repository == null)
-            return;
-        Failable<Module> result = repository.getModule(moduleName, getUpdateListener(moduleName));
-        synchronized(currentFailures) {
-            if(result instanceof Failure) {
-                Failure failure = (Failure)result;
-                currentFailures.put(moduleName, failure.errors);
-            }
-            else if(result == DoesNotExist.INSTANCE) {
-                if(currentFailures.remove(moduleName) == null)
-                    return;
-            }
-            else {
-                CompilationError[] warnings = result.getResult().getWarnings();
-                if(warnings.length == 0) {
-                    if(currentFailures.remove(moduleName) == null)
-                        return;
-                }
-                else {
-                    currentFailures.put(moduleName, warnings);
-                }
-            }
+        if(newInput != null) {
+            issueProviders = SCLIssueFactoryProvider.getSCLIssueProviderFactories().stream().map(f -> f.getSCLIssueProvider()).collect(Collectors.toList());
+            issueProviders.forEach(p -> p.listenIssues(() -> refresh()));
         }
-        refresh();
     }
-    
+
     private void refresh() {
         if(!refreshInProgress.compareAndSet(false, true))
             return;
@@ -104,54 +54,18 @@ public class SCLIssuesContentProvider implements IStructuredContentProvider {
         });
     }
 
-    private void listenIssues() {
-        new Thread() {
-            public void run() {
-                if(repository == null)
-                    return;
-                repository.getSourceRepository().forAllModules(new TObjectProcedure<String>() {
-                    @Override
-                    public boolean execute(String moduleName) {
-                        listenModule(moduleName);
-                        return true;
-                    }
-                });
-            }
-        }.start();
-    }
-
-    @Override
     public void dispose() {
         if(this.disposed)
             return;
+        issueProviders.forEach(p -> p.dispose());
+        issueProviders.clear();
         this.disposed = true;
-        if(repository != null)
-            synchronized(updateListeners) {
-                updateListeners.forEachEntry(new TObjectObjectProcedure<String, UpdateListener>() {
-                    @Override
-                    public boolean execute(String moduleName, UpdateListener listener) {
-                        listener.stopListening();
-                        return true;
-                    }
-                });
-                updateListeners.clear();
-            }
     }
 
     @Override
     public Object[] getElements(Object inputElement) {
-        ArrayList<SCLIssuesTableEntry> result = new ArrayList<SCLIssuesTableEntry>();
-        synchronized(currentFailures) {
-            String[] moduleNames = currentFailures.keySet().toArray(new String[currentFailures.size()]);
-            Arrays.sort(moduleNames);
-            for(String moduleName : moduleNames) {
-                CompilationError[] errors = currentFailures.get(moduleName);
-                for(CompilationError error : errors)
-                    result.add(new SCLIssuesTableEntry(moduleName, error));
-                if(result.size() >= MAX_ISSUE_COUNT)
-                    break;
-            }
-        }
+        ArrayList<SCLIssuesTableEntry> result = new ArrayList<>();
+        issueProviders.forEach(p -> result.addAll(p.getIssues()));
         Collections.sort(result);
         return result.toArray();
     }