Skip to content
Snippets Groups Projects
Commit 1360a251 authored by Alberto Debiasi's avatar Alberto Debiasi
Browse files

Merge remote-tracking branch 'origin/master' into neon 

Conflicts:
	plugins/org.polarsys.chess.checkers/src/org/polarsys/chess/checkers/core/checkerManager/Checker.java
	plugins/org.polarsys.chess.checkers/src/org/polarsys/chess/checkers/core/checkerManager/CheckerManager.java
	plugins/org.polarsys.chess.checkers/src/org/polarsys/chess/checkers/core/checkerManager/CheckersContainer.java

Change-Id: I82322bd32ff90a6e98bc9d5f51609ec7fcf3856a
parents 53a8e356 7c0e39f5
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 569 additions and 430 deletions
org.polarsys.chess.parent/releng/org.polarsys.chess.target.neon/org.polarsys.chess.target.neon.target
+ 8
− 0
View file @ 1360a251
...@@ -103,5 +103,13 @@ ...@@ -103,5 +103,13 @@
<unit id="org.eclipse.epsilon.emf.feature.feature.group" version="0.0.0"/> <unit id="org.eclipse.epsilon.emf.feature.feature.group" version="0.0.0"/>
<repository location="http://download.eclipse.org/epsilon/updates/1.4"/> <repository location="http://download.eclipse.org/epsilon/updates/1.4"/>
</location> </location>
<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
<unit id="eu.fbk.tools.sde.feature.feature.group" version="0.0.0"/>
<repository location="http://es-static.fbk.eu/tools/eclipse_sde_devel"/>
</location>
<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
<unit id="eu.fbk.eclipse.standardtools.feature.feature.group" version="0.0.0"/>
<repository location="http://es-static.fbk.eu/tools/eclipse_est_devel"/>
</location>
</locations> </locations>
</target> </target>
plugins/org.polarsys.chess.checkers/src/org/polarsys/chess/checkers/core/checkerManager/Checker.java
+ 188
− 136
View file @ 1360a251
...@@ -5,139 +5,191 @@ ...@@ -5,139 +5,191 @@
* which accompanies this distribution, and is available at * which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v20.html * http://www.eclipse.org/legal/epl-v20.html
******************************************************************************/ ******************************************************************************/
package org.polarsys.chess.checkers.core.checkerManager;
package org.polarsys.chess.checkers.core.checkerManager;
import java.util.ArrayList;
import java.util.List; import java.util.ArrayList;
import java.util.Set; import java.util.List;
import java.util.Set;
import org.apache.log4j.Logger;
import org.eclipse.core.resources.IFile; import org.apache.log4j.Logger;
import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.Job; import org.eclipse.core.runtime.Status;
import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; import org.eclipse.core.runtime.jobs.Job;
import org.polarsys.chess.contracts.profile.chesscontract.util.EntityUtil; import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
import org.polarsys.chess.contracts.profile.chesscontract.util.EntityUtil;
public abstract class Checker {
import org.eclipse.uml2.uml.Package;
private static final Logger logger = Logger.getLogger(Checker.class);
public abstract class Checker {
// private static String pluginID = "org.polarsys.chess.checkers";
private static final Logger logger = Logger.getLogger(Checker.class);
public final String unifiedName; public static String FAMILY = "checkers";
protected final Set<String> checkerTags;
protected final int registerPriority; // private static String pluginID = "org.polarsys.chess.checkers";
private ArrayList<Exception> errors = new ArrayList<Exception>();
public final String unifiedName;
protected Checker(String unifiedName, Set<String> checkerTags) { protected final Set<String> checkerTags;
this(unifiedName, checkerTags, 0); protected final int registerPriority;
} private ArrayList<Exception> errors = new ArrayList<Exception>();
public Checker(String unifiedName, Set<String> checkerTags, int registerPriority) { protected Checker(String unifiedName, Set<String> checkerTags) {
this(unifiedName, checkerTags, 0);
this.unifiedName = unifiedName; }
this.checkerTags = checkerTags;
this.registerPriority = registerPriority; public Checker(String unifiedName, Set<String> checkerTags, int registerPriority) {
CheckerManager checkerManager = org.polarsys.chess.checkers.Activator.getCheckerManager(); this.unifiedName = unifiedName;
logger.debug("register " + unifiedName); this.checkerTags = checkerTags;
checkerManager.getCheckersContainter().register(this); this.registerPriority = registerPriority;
}
CheckerManager checkerManager = org.polarsys.chess.checkers.Activator.getCheckerManager();
public abstract List<CheckerMessage> check(IProgressMonitor monitor) throws Exception; logger.debug("register " + unifiedName);
checkerManager.getCheckersContainter().register(this);
public abstract void init() throws Exception; }
public void asyncCheck(boolean isFirstChecker) throws Exception { public abstract List<CheckerMessage> check(IProgressMonitor monitor) throws Exception;
CheckerManager checkerManager = org.polarsys.chess.checkers.Activator.getCheckerManager(); public abstract void init() throws Exception;
org.eclipse.uml2.uml.Package pack = EntityUtil.getInstance().getCurrentSystemView(); public void asyncCheck(boolean isFirstChecker) throws Exception {
if(pack==null){ CheckerManager checkerManager = org.polarsys.chess.checkers.Activator.getCheckerManager();
IFile file = EntityUtil.getInstance().getCurrentIFile(); org.eclipse.uml2.uml.Package pack = EntityUtil.getInstance().getCurrentSystemView();
System.out.println("file: "+file); if(pack == null) {
EntityUtil.getInstance().openCurrentModelIntoEditor(file); IFile file = EntityUtil.getInstance().getCurrentIFile();
} logger.debug("file: "+file);
EntityUtil.getInstance().openCurrentModelIntoEditor(file);
IFile iFile = WorkspaceSynchronizer.getFile(EntityUtil.getInstance().getCurrentSystemView().eResource()); }
init();
IFile iFile = WorkspaceSynchronizer.getFile(EntityUtil.getInstance().getCurrentSystemView().eResource());
logger.debug("running checker: "+unifiedName); init();
Job job = new Job("Checker Manager: " + unifiedName) {
@Override logger.debug("running checker: "+unifiedName);
protected IStatus run(IProgressMonitor monitor) { Job job = new Job("Checker Manager: " + unifiedName) {
try { @Override
errors = new ArrayList<Exception>(); protected IStatus run(IProgressMonitor monitor) {
List<CheckerMessage> messages = check(monitor); try {
if (messages != null) { errors = new ArrayList<Exception>();
// checkerManager.deleteMarkers(iFile, unifiedName); List<CheckerMessage> messages = check(monitor);
checkerManager.deleteProjectMarkers(iFile.getProject(), unifiedName); if (messages != null) {
checkerManager.addMessages(unifiedName, messages); // checkerManager.deleteMarkers(iFile, unifiedName);
} checkerManager.deleteProjectMarkers(iFile.getProject(), unifiedName);
} catch (Exception e) { checkerManager.addMessages(unifiedName, messages);
e.printStackTrace(); }
logger.error("Checker '"+unifiedName+"' exception: "+e.getMessage()); } catch (Exception e) {
return Status.CANCEL_STATUS; e.printStackTrace();
} logger.error("Checker '"+unifiedName+"' exception: "+e.getMessage());
if (monitor.isCanceled()) { return Status.CANCEL_STATUS;
logger.warn("checker '" + unifiedName + "' isCanceled"); }
return Status.CANCEL_STATUS; if (monitor.isCanceled()) {
} logger.warn("checker '" + unifiedName + "' isCanceled");
// use this to open a Shell in the UI thread return Status.CANCEL_STATUS;
return Status.OK_STATUS; }
} // use this to open a Shell in the UI thread
}; return Status.OK_STATUS;
}
job.setUser(isFirstChecker); };
job.schedule();
} job.setUser(isFirstChecker);
job.schedule();
// /** }
// * Recursively returns all the files in the given container
// * @param container the IContainer /**
// * @return * Just runs the check() method and returns the scheduled job.
// */ * @param pack
// private List<IFile> getProjectFiles(IContainer container) { * @return
// final List<IFile> files = new ArrayList<IFile>(); */
// try { public Job syncCheck(Package pack) {
// for (IResource member : container.members()) { CheckerManager checkerManager = org.polarsys.chess.checkers.Activator.getCheckerManager();
// if (member instanceof IContainer) { IFile iFile = WorkspaceSynchronizer.getFile(pack.eResource());
// files.addAll(getProjectFiles((IContainer) member));
// } else if (member instanceof IFile) { logger.debug("running checker: " + unifiedName);
// files.add((IFile) member); Job job = new Job("Checker Manager: " + unifiedName) {
// } @Override
// } protected IStatus run(IProgressMonitor monitor) {
// } catch (Exception e) { try {
// e.printStackTrace(); errors = new ArrayList<Exception>();
// } List<CheckerMessage> messages = check(monitor);
// return files; checkerManager.updateCheckerStatus(unifiedName, true);
// } if (messages != null) {
checkerManager.deleteProjectMarkers(iFile.getProject(), unifiedName);
/* checkerManager.addMessages(unifiedName, messages);
* private void syncWithUI(Shell shell) { Display.getDefault().asyncExec(new }
* Runnable() { public void run() { MessageDialog.openInformation(shell, } catch (Exception e) {
* "message", "completed!"); } }); } checkerManager.updateCheckerStatus(unifiedName, true);
*/ e.printStackTrace();
logger.error("Checker '" + unifiedName + "' exception: " + e.getMessage());
public boolean belongsTo(Set<String> checkersTags) { return Status.CANCEL_STATUS;
for (String tag : checkersTags) { }
if (checkerTags.contains(tag)) if (monitor.isCanceled()) {
return true; checkerManager.updateCheckerStatus(unifiedName, true);
} logger.warn("checker '" + unifiedName + "' isCanceled");
return false; return Status.CANCEL_STATUS;
} }
// use this to open a Shell in the UI thread
public String getUnifiedName() { return Status.OK_STATUS;
return unifiedName; }
}
@Override
public Set<String> getCheckerTags() { public boolean belongsTo(Object family) {
return checkerTags; if (Checker.FAMILY.equals(family)) {
} return true;
} else {
public void addError(Exception e){ return false;
errors.add(e); }
} }
} };
job.schedule();
return job;
}
// /**
// * Recursively returns all the files in the given container
// * @param container the IContainer
// * @return
// */
// private List<IFile> getProjectFiles(IContainer container) {
// final List<IFile> files = new ArrayList<IFile>();
// try {
// for (IResource member : container.members()) {
// if (member instanceof IContainer) {
// files.addAll(getProjectFiles((IContainer) member));
// } else if (member instanceof IFile) {
// files.add((IFile) member);
// }
// }
// } catch (Exception e) {
// e.printStackTrace();
// }
// return files;
// }
/*
* private void syncWithUI(Shell shell) { Display.getDefault().asyncExec(new
* Runnable() { public void run() { MessageDialog.openInformation(shell,
* "message", "completed!"); } }); }
*/
public boolean belongsTo(Set<String> checkersTags) {
for (String tag : checkersTags) {
if (checkerTags.contains(tag))
return true;
}
return false;
}
public String getUnifiedName() {
return unifiedName;
}
public Set<String> getCheckerTags() {
return checkerTags;
}
public void addError(Exception e){
errors.add(e);
}
}
plugins/org.polarsys.chess.checkers/src/org/polarsys/chess/checkers/core/checkerManager/CheckerManager.java
+ 272
− 222
View file @ 1360a251
...@@ -5,225 +5,275 @@ ...@@ -5,225 +5,275 @@
* which accompanies this distribution, and is available at * which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v20.html * http://www.eclipse.org/legal/epl-v20.html
******************************************************************************/ ******************************************************************************/
package org.polarsys.chess.checkers.core.checkerManager; package org.polarsys.chess.checkers.core.checkerManager;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import org.apache.log4j.Logger;
import org.apache.log4j.Logger; import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.ecore.EObject; import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.emf.ecore.EValidator; import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.emf.ecore.EObject;
import org.eclipse.papyrus.views.modelexplorer.ModelExplorerPage; import org.eclipse.emf.ecore.EValidator;
import org.eclipse.papyrus.views.modelexplorer.ModelExplorerPageBookView; import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.papyrus.views.modelexplorer.ModelExplorerView; import org.eclipse.papyrus.views.modelexplorer.ModelExplorerPage;
import org.eclipse.ui.IViewPart; import org.eclipse.papyrus.views.modelexplorer.ModelExplorerPageBookView;
import org.eclipse.ui.IWorkbench; import org.eclipse.papyrus.views.modelexplorer.ModelExplorerView;
import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PartInitException; import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI; import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.part.IPage; import org.eclipse.ui.PartInitException;
import org.eclipse.uml2.uml.NamedElement; import org.eclipse.ui.PlatformUI;
import org.eclipse.xtext.nodemodel.INode; import org.eclipse.ui.part.IPage;
import org.polarsys.chess.service.gui.utils.ReportProblemsUtil; import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Package;
public class CheckerManager { import org.eclipse.xtext.nodemodel.INode;
import org.polarsys.chess.service.gui.utils.ReportProblemsUtil;
private static final Logger logger = Logger.getLogger(CheckerManager.class);
public class CheckerManager {
private static final String CHECKER_NAME = "checkerName";
List<CheckersContainer> checkersContainers; private static final Logger logger = Logger.getLogger(CheckerManager.class);
List<CheckerMessage> messages;
HashMap<String, Boolean> checkerStatus; private static final String CHECKER_NAME = "checkerName";
List<CheckersContainer> checkersContainers;
// ModelExplorerPageBookView modelExplorerPageBookView; List<CheckerMessage> messages;
// ModelExplorerView modelExplorerView ; HashMap<String, Boolean> checkerStatus;
// test test;
public CheckerManager() { // ModelExplorerPageBookView modelExplorerPageBookView;
logger.debug("Instantiate CheckerManager"); // ModelExplorerView modelExplorerView ;
this.checkersContainers = new ArrayList<CheckersContainer>(); // test test;
new CheckersContainer(this); public CheckerManager() {
// checkersContainers.add(checkersContainer); logger.debug("Instantiate CheckerManager");
} this.checkersContainers = new ArrayList<CheckersContainer>();
new CheckersContainer(this);
public void run(Set<String> selectedCheckersTags) throws Exception { // checkersContainers.add(checkersContainer);
logger.debug("run"); }
checkerStatus = new HashMap<String, Boolean>();
messages = new ArrayList<CheckerMessage>(); public void run(Set<String> selectedCheckersTags) throws Exception {
// modelExplorerPageBookView = getModelExplorerPageBookView(); logger.debug("run");
// modelExplorerView = getModelExplorerView(); checkerStatus = new HashMap<String, Boolean>();
// test = new test(modelExplorerView); messages = new ArrayList<CheckerMessage>();
for (CheckersContainer checkersContainer : checkersContainers) { // modelExplorerPageBookView = getModelExplorerPageBookView();
logger.debug("run checkersContainer"); // modelExplorerView = getModelExplorerView();
checkersContainer.run(selectedCheckersTags); // test = new test(modelExplorerView);
} for (CheckersContainer checkersContainer : checkersContainers) {
} logger.debug("run checkersContainer");
checkersContainer.run(selectedCheckersTags);
public void register(CheckersContainer checkersContainer) { }
logger.debug("register CheckersContainer"); }
this.checkersContainers.add(checkersContainer);
} /**
* Launches the init() of the various checkerContainers.
public Set<String> getTags() { * @param selectedCheckersTags
Set<String> tags = new HashSet<String>(); * @throws Exception
*/
for (CheckersContainer containter : checkersContainers) { public void initSync(Set<String> selectedCheckersTags) throws Exception {
tags.addAll(containter.getTags()); logger.debug("initSync");
} for (CheckersContainer checkersContainer : checkersContainers) {
logger.debug("init checkersContainer");
return tags; checkersContainer.initSync(selectedCheckersTags);
} }
}
public CheckersContainer getCheckersContainter() {
return checkersContainers.get(0); /**
} * Launches the check() of the various checkerContainers and waits for their finish.
* @param selectedCheckersTags
public void addMessages(String unifiedName, List<CheckerMessage> newMessages) throws Exception { * @param pkg
// this.messages.addAll(newMessages); * @return
checkerStatus.put(unifiedName, true); */
public List<Exception> checkSync(Set<String> selectedCheckersTags, Package pkg, IProgressMonitor monitor) {
// logger.debug("addMessages '" + unifiedName + "' : " + logger.debug("runSync");
// newMessages.size()); final List<Exception> errors = new ArrayList<Exception>();
checkerStatus = new HashMap<String, Boolean>();
/* messages = new ArrayList<CheckerMessage>();
* for (Boolean value : checkerStatus.values()) { if final List<Job> jobs = new ArrayList<Job>();
* (value.booleanValue() == false) return; }
*/ // Start all the checks()
for (CheckersContainer checkersContainer : checkersContainers) {
// IViewPart modelexplorer = logger.debug("run checkersContainer");
// PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage() jobs.addAll(checkersContainer.checkSync(selectedCheckersTags, pkg));
// .showView(ModelExplorerPageBookView.VIEW_ID); }
// modelExplorerView = getModelExplorerPageBookView();
// System.out.println("modelexplorer: "+modelExplorerView); // Wait for the checks to finish
try {
// Set<IFile> iFiles = extractIFiles(newMessages); Job.getJobManager().join(Checker.FAMILY, monitor);
} catch (OperationCanceledException | InterruptedException e1) {
// for (IFile iFile : iFiles) { logger.debug("Checker execution interrupted");
// deleteMarkers(iFile, unifiedName); for (Job job : jobs) {
// } job.cancel();
}
for (CheckerMessage msn : newMessages) { errors.add(new Exception("Esecuzione checker interrotta"));
if (msn.object != null && msn.object instanceof EObject) { e1.printStackTrace();
IMarker marker = msn.file.createMarker(EValidator.MARKER); }
marker.setAttribute(CHECKER_NAME, msn.checkerName); return errors;
marker.setAttribute(IMarker.MESSAGE, msn.message); }
String location = EcoreUtil.getURI((EObject) msn.object).toString();
if (msn.object instanceof NamedElement) { public void register(CheckersContainer checkersContainer) {
location = ((NamedElement) msn.object).getQualifiedName(); logger.debug("register CheckersContainer");
} this.checkersContainers.add(checkersContainer);
marker.setAttribute(IMarker.LOCATION, location); }
marker.setAttribute(IMarker.SEVERITY, msn.severity);
marker.setAttribute(EValidator.URI_ATTRIBUTE, EcoreUtil.getURI((EObject) msn.object).toString()); public Set<String> getTags() {
} else if (msn.object != null && msn.object instanceof INode) { Set<String> tags = new HashSet<String>();
try {
final INode node = (INode) msn.object; for (CheckersContainer containter : checkersContainers) {
if (msn.severity == IMarker.SEVERITY_INFO) { tags.addAll(containter.getTags());
ReportProblemsUtil.reportInfo(msn.file, CHECKER_NAME, msn.checkerName, msn.message, node.getStartLine(), }
node.getOffset(), node.getEndOffset());
} else if (msn.severity == IMarker.SEVERITY_WARNING) { return tags;
ReportProblemsUtil.reportWarning(msn.file, CHECKER_NAME, msn.checkerName, msn.message, node.getStartLine(), }
node.getOffset(), node.getEndOffset());
} else if (msn.severity == IMarker.SEVERITY_ERROR) { public CheckersContainer getCheckersContainter() {
ReportProblemsUtil.reportError(msn.file, CHECKER_NAME, msn.checkerName, msn.message, node.getStartLine(), return checkersContainers.get(0);
node.getOffset(), node.getEndOffset()); }
}
} catch (NullPointerException | CoreException e) { public void addMessages(String unifiedName, List<CheckerMessage> newMessages) throws Exception {
e.printStackTrace(); // this.messages.addAll(newMessages);
} checkerStatus.put(unifiedName, true);
}
} // logger.debug("addMessages '" + unifiedName + "' : " +
} // newMessages.size());
private Set<IFile> extractIFiles(List<CheckerMessage> checkerMessages) { /*
* for (Boolean value : checkerStatus.values()) { if
Set<IFile> iFiles = new HashSet<IFile>(); * (value.booleanValue() == false) return; }
if (checkerMessages != null) { */
for (CheckerMessage checkerMessage : checkerMessages) {
if (checkerMessage.file != null) { // IViewPart modelexplorer =
iFiles.add(checkerMessage.file); // PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()
} // .showView(ModelExplorerPageBookView.VIEW_ID);
} // modelExplorerView = getModelExplorerPageBookView();
} // System.out.println("modelexplorer: "+modelExplorerView);
return iFiles;
} // Set<IFile> iFiles = extractIFiles(newMessages);
void deleteMarkers(IFile file, String checkerName) throws CoreException { // for (IFile iFile : iFiles) {
IMarker[] markers = file.findMarkers(EValidator.MARKER, false, IResource.DEPTH_ONE); // deleteMarkers(iFile, unifiedName);
for (IMarker marker : markers) { // }
if (marker != null && marker.exists() && marker.getAttribute(CHECKER_NAME, "").equals(checkerName)) {
marker.delete(); for (CheckerMessage msn : newMessages) {
} if (msn.object != null && msn.object instanceof EObject) {
} IMarker marker = msn.file.createMarker(EValidator.MARKER);
} marker.setAttribute(CHECKER_NAME, msn.checkerName);
marker.setAttribute(IMarker.MESSAGE, msn.message);
/** String location = EcoreUtil.getURI((EObject) msn.object).toString();
* Deletes all the matching markers inside the given project. if (msn.object instanceof NamedElement) {
* @param project the active project location = ((NamedElement) msn.object).getQualifiedName();
* @param checkerName the name of the creating checker }
* @throws CoreException marker.setAttribute(IMarker.LOCATION, location);
*/ marker.setAttribute(IMarker.SEVERITY, msn.severity);
void deleteProjectMarkers(IProject project, String checkerName) throws CoreException { marker.setAttribute(EValidator.URI_ATTRIBUTE, EcoreUtil.getURI((EObject) msn.object).toString());
IMarker[] markers = project.findMarkers(null, false, IResource.DEPTH_INFINITE); } else if (msn.object != null && msn.object instanceof INode) {
for (IMarker marker : markers) { try {
if (marker != null && marker.exists() && marker.getAttribute(CHECKER_NAME, "").equals(checkerName)) { final INode node = (INode) msn.object;
marker.delete(); if (msn.severity == IMarker.SEVERITY_INFO) {
} ReportProblemsUtil.reportInfo(msn.file, CHECKER_NAME, msn.checkerName, msn.message, node.getStartLine(),
} node.getOffset(), node.getEndOffset());
} } else if (msn.severity == IMarker.SEVERITY_WARNING) {
ReportProblemsUtil.reportWarning(msn.file, CHECKER_NAME, msn.checkerName, msn.message, node.getStartLine(),
private ModelExplorerPageBookView getModelExplorerPageBookView() { node.getOffset(), node.getEndOffset());
} else if (msn.severity == IMarker.SEVERITY_ERROR) {
IWorkbench workbench = PlatformUI.getWorkbench(); ReportProblemsUtil.reportError(msn.file, CHECKER_NAME, msn.checkerName, msn.message, node.getStartLine(),
node.getOffset(), node.getEndOffset());
System.out.println("workbench: " + workbench); }
IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); } catch (NullPointerException | CoreException e) {
e.printStackTrace();
System.out.println("window: " + window); }
}
IWorkbenchPage workbenchPage = window.getActivePage(); }
}
System.out.println("workbenchPage: " + workbenchPage);
private Set<IFile> extractIFiles(List<CheckerMessage> checkerMessages) {
IViewPart modelExplorerViewPart = null;
Set<IFile> iFiles = new HashSet<IFile>();
for (IViewPart view : workbenchPage.getViews()) { if (checkerMessages != null) {
System.out.println("view: " + view.getTitle()); for (CheckerMessage checkerMessage : checkerMessages) {
} if (checkerMessage.file != null) {
iFiles.add(checkerMessage.file);
try { }
modelExplorerViewPart = window.getActivePage().showView(ModelExplorerPageBookView.VIEW_ID); }
} catch (PartInitException ex) { }
ex.printStackTrace(System.out); return iFiles;
} }
ModelExplorerPageBookView view = (ModelExplorerPageBookView) modelExplorerViewPart; void deleteMarkers(IFile file, String checkerName) throws CoreException {
return view; IMarker[] markers = file.findMarkers(EValidator.MARKER, false, IResource.DEPTH_ONE);
for (IMarker marker : markers) {
} if (marker != null && marker.exists() && marker.getAttribute(CHECKER_NAME, "").equals(checkerName)) {
marker.delete();
private ModelExplorerView getModelExplorerView() { }
}
ModelExplorerPageBookView view = getModelExplorerPageBookView(); }
IPage currentPage = view.getCurrentPage();
ModelExplorerPage page = (ModelExplorerPage) currentPage; /**
IViewPart viewer = page.getViewer(); * Deletes all the matching markers inside the given project.
ModelExplorerView modelExplorerView = (ModelExplorerView) viewer; * @param project the active project
* @param checkerName the name of the creating checker
return modelExplorerView; * @throws CoreException
*/
} void deleteProjectMarkers(IProject project, String checkerName) throws CoreException {
IMarker[] markers = project.findMarkers(null, false, IResource.DEPTH_INFINITE);
public void updateCheckerStatus(String unifiedName, boolean b) { for (IMarker marker : markers) {
checkerStatus.put(unifiedName, b); if (marker != null && marker.exists() && marker.getAttribute(CHECKER_NAME, "").equals(checkerName)) {
} marker.delete();
}
} }
}
private ModelExplorerPageBookView getModelExplorerPageBookView() {
IWorkbench workbench = PlatformUI.getWorkbench();
System.out.println("workbench: " + workbench);
IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
System.out.println("window: " + window);
IWorkbenchPage workbenchPage = window.getActivePage();
System.out.println("workbenchPage: " + workbenchPage);
IViewPart modelExplorerViewPart = null;
for (IViewPart view : workbenchPage.getViews()) {
System.out.println("view: " + view.getTitle());
}
try {
modelExplorerViewPart = window.getActivePage().showView(ModelExplorerPageBookView.VIEW_ID);
} catch (PartInitException ex) {
ex.printStackTrace(System.out);
}
ModelExplorerPageBookView view = (ModelExplorerPageBookView) modelExplorerViewPart;
return view;
}
private ModelExplorerView getModelExplorerView() {
ModelExplorerPageBookView view = getModelExplorerPageBookView();
IPage currentPage = view.getCurrentPage();
ModelExplorerPage page = (ModelExplorerPage) currentPage;
IViewPart viewer = page.getViewer();
ModelExplorerView modelExplorerView = (ModelExplorerView) viewer;
return modelExplorerView;
}
public void updateCheckerStatus(String unifiedName, boolean b) {
checkerStatus.put(unifiedName, b);
}
}
plugins/org.polarsys.chess.checkers/src/org/polarsys/chess/checkers/core/checkerManager/CheckersContainer.java
+ 101
− 72
View file @ 1360a251
...@@ -5,75 +5,104 @@ ...@@ -5,75 +5,104 @@
* which accompanies this distribution, and is available at * which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v20.html * http://www.eclipse.org/legal/epl-v20.html
******************************************************************************/ ******************************************************************************/
package org.polarsys.chess.checkers.core.checkerManager; package org.polarsys.chess.checkers.core.checkerManager;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.Set; import java.util.Set;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.eclipse.core.runtime.jobs.Job;
public class CheckersContainer { import org.eclipse.uml2.uml.Package;
private static final Logger logger = Logger.getLogger(CheckersContainer.class); public class CheckersContainer {
List<Checker> checkers; private static final Logger logger = Logger.getLogger(CheckersContainer.class);
CheckerManager checkerManager;
List<Checker> checkers;
public CheckersContainer(CheckerManager checkerManager) { CheckerManager checkerManager;
this.checkers = new ArrayList<Checker>();
this.checkerManager = checkerManager; public CheckersContainer(CheckerManager checkerManager) {
checkerManager.register(this); this.checkers = new ArrayList<Checker>();
} this.checkerManager = checkerManager;
checkerManager.register(this);
public void run(Set<String> checkersTags) throws Exception { }
boolean isFirstChecker = true; public void run(Set<String> checkersTags) throws Exception {
boolean isFirstChecker = true;
for (Checker checker : checkers) {
for (Checker checker : checkers) {
checkerManager.updateCheckerStatus(checker.unifiedName, false); checkerManager.updateCheckerStatus(checker.unifiedName, false);
if (checker.belongsTo(checkersTags)) {
if (checker.belongsTo(checkersTags)) { logger.debug("run " + checker.getUnifiedName());
logger.debug("run " + checker.getUnifiedName()); checker.asyncCheck(isFirstChecker);
checker.asyncCheck(isFirstChecker); isFirstChecker=false;
isFirstChecker=false; }
} }
} }
} /**
* Runs the init() of the selected checkers.
public void register(Checker checker) { * @param checkersTags
Optional<Checker> alreadyRegisteredChecker = find(this.checkers,checker.unifiedName); * @throws Exception
if(!alreadyRegisteredChecker.isPresent()){ */
logger.debug("register checker not present: "+checker.registerPriority); public void initSync(Set<String> checkersTags) throws Exception {
this.checkers.add(checker); for (Checker checker : checkers) {
}else if((alreadyRegisteredChecker.get().registerPriority < checker.registerPriority)){ if (checker.belongsTo(checkersTags)) {
logger.debug("register checker already registered with priority: "+alreadyRegisteredChecker.get().registerPriority); logger.debug("init " + checker.getUnifiedName());
logger.debug("checker to register with priority: "+checker.registerPriority); checker.init();
}
this.checkers.remove(alreadyRegisteredChecker.get()); }
this.checkers.add(checker); }
//return;
} /**
//this.checkers.add(checker); * Runs the check() of the selected checkers and returns the scheduled jobs.
} * @param checkersTags
* @return the list of scheduled jobs
public Optional<Checker> find(final List<Checker> list, final String name){ */
return list.stream().filter(o -> o.unifiedName.equals(name)).findFirst(); public List<Job> checkSync(Set<String> checkersTags, Package pkg) {
} final List<Job> jobs = new ArrayList<Job>();
for (Checker checker : checkers) {
public Collection<? extends String> getTags() { checkerManager.updateCheckerStatus(checker.unifiedName, false);
Set<String> tags = new HashSet<String>(); if (checker.belongsTo(checkersTags)) {
for (Checker checker : checkers) { logger.debug("run " + checker.getUnifiedName());
tags.addAll(checker.getCheckerTags()); jobs.add(checker.syncCheck(pkg));
} }
return tags; }
} return jobs;
}
public void register(Checker checker) {
} Optional<Checker> alreadyRegisteredChecker = find(this.checkers,checker.unifiedName);
if(!alreadyRegisteredChecker.isPresent()){
logger.debug("register checker not present: "+checker.registerPriority);
this.checkers.add(checker);
}else if((alreadyRegisteredChecker.get().registerPriority < checker.registerPriority)){
logger.debug("register checker already registered with priority: "+alreadyRegisteredChecker.get().registerPriority);
logger.debug("checker to register with priority: "+checker.registerPriority);
this.checkers.remove(alreadyRegisteredChecker.get());
this.checkers.add(checker);
//return;
}
//this.checkers.add(checker);
}
public Optional<Checker> find(final List<Checker> list, final String name){
return list.stream().filter(o -> o.unifiedName.equals(name)).findFirst();
}
public Collection<? extends String> getTags() {
Set<String> tags = new HashSet<String>();
for (Checker checker : checkers) {
tags.addAll(checker.getCheckerTags());
}
return tags;
}
}
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Copyright © Eclipse Foundation, Inc. All Rights Reserved.     Privacy Policy | Terms of Use | Copyright Agent