bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/issues/SCLIssuesContentProvider.java

   1 package org.simantics.scl.ui.issues;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.Collections;
   6 import java.util.concurrent.atomic.AtomicBoolean;
   7
   8 import org.eclipse.jface.viewers.IStructuredContentProvider;
   9 import org.eclipse.jface.viewers.Viewer;
  10 import org.eclipse.swt.widgets.Control;
  11 import org.simantics.scl.compiler.errors.CompilationError;
  12 import org.simantics.scl.compiler.errors.Failable;
  13 import org.simantics.scl.compiler.errors.Failure;
  14 import org.simantics.scl.compiler.module.Module;
  15 import org.simantics.scl.compiler.module.repository.ModuleRepository;
  16 import org.simantics.scl.compiler.module.repository.UpdateListener;
  17
  18 import gnu.trove.map.hash.THashMap;
  19 import gnu.trove.procedure.TObjectProcedure;
  20
  21 public class SCLIssuesContentProvider implements IStructuredContentProvider {
  22
  23     public static final int MAX_ISSUE_COUNT = 1000;
  24
  25     Viewer viewer;
  26     ModuleRepository repository;
  27     boolean disposed = false;
  28     AtomicBoolean refreshInProgress = new AtomicBoolean(false);
  29
  30     THashMap<String, Failure> currentFailures = new THashMap<String, Failure>();
  31     THashMap<String, UpdateListener> updateListeners = new THashMap<String, UpdateListener>();
  32
  33     @Override
  34     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  35         this.viewer = viewer;
  36         this.repository = (ModuleRepository)newInput;
  37         if(newInput != null)
  38             listenIssues();
  39     }
  40
  41     private UpdateListener getUpdateListener(String moduleName) {
  42         UpdateListener listener = updateListeners.get(moduleName);
  43         if(listener == null) {
  44             listener = new UpdateListener() {
  45                 @Override
  46                 public void notifyAboutUpdate() {
  47                     if(!disposed)
  48                         listenModule(moduleName);
  49                 }
  50             };
  51             updateListeners.put(moduleName, listener);
  52         }
  53         return listener;
  54     }
  55
  56     private void listenModule(String moduleName) {
  57         if(repository == null)
  58             return;
  59         Failable<Module> result = repository.getModule(moduleName, getUpdateListener(moduleName));
  60         synchronized(currentFailures) {
  61             if(result instanceof Failure) {
  62                 Failure failure = (Failure)result;
  63                 currentFailures.put(moduleName, failure);
  64             }
  65             else
  66                 if(currentFailures.remove(moduleName) == null)
  67                     return;
  68         }
  69         refresh();
  70     }
  71
  72     private void refresh() {
  73         if(!refreshInProgress.compareAndSet(false, true))
  74             return;
  75         if(viewer == null)
  76             return;
  77         Control control = viewer.getControl();
  78         if(control.isDisposed() || disposed)
  79             return;
  80         control.getDisplay().asyncExec(new Runnable() {
  81             @Override
  82             public void run() {
  83                 if(control.isDisposed() || disposed)
  84                     return;
  85                 refreshInProgress.set(false);
  86                 viewer.refresh();
  87             }
  88         });
  89     }
  90
  91     private void listenIssues() {
  92         new Thread() {
  93             public void run() {
  94                 if(repository == null)
  95                     return;
  96                 repository.getSourceRepository().forAllModules(new TObjectProcedure<String>() {
  97                     @Override
  98                     public boolean execute(String moduleName) {
  99                         listenModule(moduleName);
 100                         return true;
 101                     }
 102                 });
 103             }
 104         }.start();
 105     }
 106
 107     @Override
 108     public void dispose() {
 109         this.disposed = true;
 110     }
 111
 112     @Override
 113     public Object[] getElements(Object inputElement) {
 114         ArrayList<SCLIssuesTableEntry> result = new ArrayList<SCLIssuesTableEntry>();
 115         synchronized(currentFailures) {
 116             String[] moduleNames = currentFailures.keySet().toArray(new String[currentFailures.size()]);
 117             Arrays.sort(moduleNames);
 118             for(String moduleName : moduleNames) {
 119                 Failure failure = currentFailures.get(moduleName);
 120                 for(CompilationError error : failure.errors)
 121                     result.add(new SCLIssuesTableEntry(moduleName, error));
 122                 if(result.size() >= MAX_ISSUE_COUNT)
 123                     break;
 124             }
 125         }
 126         Collections.sort(result);
 127         return result.toArray();
 128     }
 129
 130 }