private void updateRightTreeModel() {
Set<PsiFile> deps = new HashSet<PsiFile>();
Set<PsiFile> scope = getSelectedScope(myLeftTree);
myIllegalsInRightTree = new HashSet<PsiFile>();
for (PsiFile psiFile : scope) {
Map<DependencyRule, Set<PsiFile>> illegalDeps = myIllegalDependencies.get(psiFile);
if (illegalDeps != null) {
for (final DependencyRule rule : illegalDeps.keySet()) {
myIllegalsInRightTree.addAll(illegalDeps.get(rule));
}
}
final Set<PsiFile> psiFiles = myDependencies.get(psiFile);
if (psiFiles != null) {
for (PsiFile file : psiFiles) {
if (file != null && file.isValid()) {
deps.add(file);
}
}
}
}
deps.removeAll(scope);
myRightTreeExpansionMonitor.freeze();
myRightTree.setModel(buildTreeModel(deps, myRightTreeMarker));
myRightTreeExpansionMonitor.restore();
expandFirstLevel(myRightTree);
}
@Override
public void addRow() {
final Set<Module> projectModules =
new HashSet<Module>(Arrays.asList(ModuleManager.getInstance(myProject).getModules()));
projectModules.removeAll(getAllModules());
final ChooseModulesDialog chooser =
new ChooseModulesDialog(
ProcessedModulesTable.this, new ArrayList<Module>(projectModules), "ChooseModule");
if (chooser.showAndGet()) {
final List<Module> chosen = chooser.getChosenElements();
for (Module module : chosen) {
addElement(module, null);
}
}
}
@Nullable
private AnalysisScope getScope() {
final Set<PsiFile> selectedScope = getSelectedScope(myRightTree);
Set<PsiFile> result = new HashSet<PsiFile>();
((PackageDependenciesNode) myLeftTree.getModel().getRoot())
.fillFiles(result, !mySettings.UI_FLATTEN_PACKAGES);
selectedScope.removeAll(result);
if (selectedScope.isEmpty()) return null;
List<VirtualFile> files = new ArrayList<VirtualFile>();
final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
for (PsiFile psiFile : selectedScope) {
final VirtualFile file = psiFile.getVirtualFile();
LOG.assertTrue(file != null);
if (fileIndex.isInContent(file)) {
files.add(file);
}
}
if (!files.isEmpty()) {
return new AnalysisScope(myProject, files);
}
return null;
}
@NotNull
@Override
public List<SearchScope> getPredefinedScopes(
@NotNull final Project project,
@Nullable final DataContext dataContext,
boolean suggestSearchInLibs,
boolean prevSearchFiles,
boolean currentSelection,
boolean usageView,
boolean showEmptyScopes) {
Collection<SearchScope> result = ContainerUtil.newLinkedHashSet();
result.add(GlobalSearchScope.projectScope(project));
if (suggestSearchInLibs) {
result.add(GlobalSearchScope.allScope(project));
}
if (ModuleUtil.isSupportedRootType(project, JavaSourceRootType.TEST_SOURCE)) {
result.add(GlobalSearchScopesCore.projectProductionScope(project));
result.add(GlobalSearchScopesCore.projectTestScope(project));
}
final GlobalSearchScope openFilesScope = GlobalSearchScopes.openFilesScope(project);
if (openFilesScope != GlobalSearchScope.EMPTY_SCOPE) {
result.add(openFilesScope);
} else if (showEmptyScopes) {
result.add(
new LocalSearchScope(PsiElement.EMPTY_ARRAY, IdeBundle.message("scope.open.files")));
}
final Editor selectedTextEditor =
ApplicationManager.getApplication().isDispatchThread()
? FileEditorManager.getInstance(project).getSelectedTextEditor()
: null;
final PsiFile psiFile =
(selectedTextEditor != null)
? PsiDocumentManager.getInstance(project).getPsiFile(selectedTextEditor.getDocument())
: null;
PsiFile currentFile = psiFile;
if (dataContext != null) {
PsiElement dataContextElement = CommonDataKeys.PSI_FILE.getData(dataContext);
if (dataContextElement == null) {
dataContextElement = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
}
if (dataContextElement == null && psiFile != null) {
dataContextElement = psiFile;
}
if (dataContextElement != null) {
if (!PlatformUtils.isCidr()) { // TODO: have an API to disable module scopes.
Module module = ModuleUtilCore.findModuleForPsiElement(dataContextElement);
if (module == null) {
module = LangDataKeys.MODULE.getData(dataContext);
}
if (module != null && !(ModuleType.get(module) instanceof InternalModuleType)) {
result.add(module.getModuleScope());
}
}
if (currentFile == null) {
currentFile = dataContextElement.getContainingFile();
}
}
}
if (currentFile != null || showEmptyScopes) {
PsiElement[] scope =
currentFile != null ? new PsiElement[] {currentFile} : PsiElement.EMPTY_ARRAY;
result.add(new LocalSearchScope(scope, IdeBundle.message("scope.current.file")));
}
if (currentSelection && selectedTextEditor != null && psiFile != null) {
SelectionModel selectionModel = selectedTextEditor.getSelectionModel();
if (selectionModel.hasSelection()) {
int start = selectionModel.getSelectionStart();
final PsiElement startElement = psiFile.findElementAt(start);
if (startElement != null) {
int end = selectionModel.getSelectionEnd();
final PsiElement endElement = psiFile.findElementAt(end);
if (endElement != null) {
final PsiElement parent = PsiTreeUtil.findCommonParent(startElement, endElement);
if (parent != null) {
final List<PsiElement> elements = new ArrayList<PsiElement>();
final PsiElement[] children = parent.getChildren();
TextRange selection = new TextRange(start, end);
for (PsiElement child : children) {
if (!(child instanceof PsiWhiteSpace)
&& child.getContainingFile() != null
&& selection.contains(child.getTextOffset())) {
elements.add(child);
}
}
if (!elements.isEmpty()) {
SearchScope local =
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(elements),
IdeBundle.message("scope.selection"));
result.add(local);
}
}
}
}
}
}
if (usageView) {
addHierarchyScope(project, result);
UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView();
if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) {
final Set<Usage> usages = ContainerUtil.newTroveSet(selectedUsageView.getUsages());
usages.removeAll(selectedUsageView.getExcludedUsages());
final List<PsiElement> results = new ArrayList<PsiElement>(usages.size());
if (prevSearchFiles) {
final Set<VirtualFile> files = collectFiles(usages, true);
if (!files.isEmpty()) {
GlobalSearchScope prev =
new GlobalSearchScope(project) {
private Set<VirtualFile> myFiles = null;
@NotNull
@Override
public String getDisplayName() {
return IdeBundle.message("scope.files.in.previous.search.result");
}
@Override
public synchronized boolean contains(@NotNull VirtualFile file) {
if (myFiles == null) {
myFiles = collectFiles(usages, false);
}
return myFiles.contains(file);
}
@Override
public int compare(@NotNull VirtualFile file1, @NotNull VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
};
result.add(prev);
}
} else {
for (Usage usage : usages) {
if (usage instanceof PsiElementUsage) {
final PsiElement element = ((PsiElementUsage) usage).getElement();
if (element != null && element.isValid() && element.getContainingFile() != null) {
results.add(element);
}
}
}
if (!results.isEmpty()) {
result.add(
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(results),
IdeBundle.message("scope.previous.search.results")));
}
}
}
}
final FavoritesManager favoritesManager = FavoritesManager.getInstance(project);
if (favoritesManager != null) {
for (final String favorite : favoritesManager.getAvailableFavoritesListNames()) {
final Collection<TreeItem<Pair<AbstractUrl, String>>> rootUrls =
favoritesManager.getFavoritesListRootUrls(favorite);
if (rootUrls.isEmpty()) continue; // ignore unused root
result.add(
new GlobalSearchScope(project) {
@NotNull
@Override
public String getDisplayName() {
return "Favorite \'" + favorite + "\'";
}
@Override
public boolean contains(@NotNull final VirtualFile file) {
return ApplicationManager.getApplication()
.runReadAction(
(Computable<Boolean>) () -> favoritesManager.contains(favorite, file));
}
@Override
public int compare(
@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull final Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
});
}
}
ContainerUtil.addIfNotNull(result, getSelectedFilesScope(project, dataContext));
return ContainerUtil.newArrayList(result);
}
public void install(@Nullable final Runnable onSuccess, boolean confirmed) {
IdeaPluginDescriptor[] selection = getPluginTable().getSelectedObjects();
if (confirmed || userConfirm(selection)) {
final List<PluginNode> list = new ArrayList<PluginNode>();
for (IdeaPluginDescriptor descr : selection) {
PluginNode pluginNode = null;
if (descr instanceof PluginNode) {
pluginNode = (PluginNode) descr;
} else if (descr instanceof IdeaPluginDescriptorImpl) {
PluginId pluginId = descr.getPluginId();
pluginNode = new PluginNode(pluginId);
pluginNode.setName(descr.getName());
pluginNode.setDepends(
Arrays.asList(descr.getDependentPluginIds()), descr.getOptionalDependentPluginIds());
pluginNode.setSize("-1");
pluginNode.setRepositoryName(PluginInstaller.UNKNOWN_HOST_MARKER);
}
if (pluginNode != null) {
list.add(pluginNode);
ourInstallingNodes.add(pluginNode);
}
}
final InstalledPluginsTableModel installedModel =
(InstalledPluginsTableModel) myInstalled.getPluginsModel();
final Set<IdeaPluginDescriptor> disabled = new HashSet<IdeaPluginDescriptor>();
final Set<IdeaPluginDescriptor> disabledDependants = new HashSet<IdeaPluginDescriptor>();
for (PluginNode node : list) {
final PluginId pluginId = node.getPluginId();
if (installedModel.isDisabled(pluginId)) {
disabled.add(node);
}
final List<PluginId> depends = node.getDepends();
if (depends != null) {
final Set<PluginId> optionalDeps =
new HashSet<PluginId>(Arrays.asList(node.getOptionalDependentPluginIds()));
for (PluginId dependantId : depends) {
if (optionalDeps.contains(dependantId)) continue;
final IdeaPluginDescriptor pluginDescriptor = PluginManager.getPlugin(dependantId);
if (pluginDescriptor != null && installedModel.isDisabled(dependantId)) {
disabledDependants.add(pluginDescriptor);
}
}
}
}
if (suggestToEnableInstalledPlugins(installedModel, disabled, disabledDependants, list)) {
myInstalled.setRequireShutdown(true);
}
try {
Runnable onInstallRunnable =
new Runnable() {
@Override
public void run() {
for (PluginNode node : list) {
installedModel.appendOrUpdateDescriptor(node);
}
if (!myInstalled.isDisposed()) {
getPluginTable().updateUI();
myInstalled.setRequireShutdown(true);
} else {
boolean needToRestart = false;
for (PluginNode node : list) {
final IdeaPluginDescriptor pluginDescriptor =
PluginManager.getPlugin(node.getPluginId());
if (pluginDescriptor == null || pluginDescriptor.isEnabled()) {
needToRestart = true;
break;
}
}
if (needToRestart) {
PluginManagerMain.notifyPluginsUpdated(null);
}
}
if (onSuccess != null) {
onSuccess.run();
}
}
};
Runnable cleanupRunnable =
new Runnable() {
@Override
public void run() {
ourInstallingNodes.removeAll(list);
}
};
PluginManagerMain.downloadPlugins(
list, myHost.getPluginsModel().getAllPlugins(), onInstallRunnable, cleanupRunnable);
} catch (final IOException e1) {
ourInstallingNodes.removeAll(list);
PluginManagerMain.LOG.error(e1);
//noinspection SSBasedInspection
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
IOExceptionDialog.showErrorDialog(
IdeBundle.message("action.download.and.install.plugin"),
IdeBundle.message("error.plugin.download.failed"));
}
});
}
}
}
@Override
@SuppressWarnings("HardCodedStringLiteral")
public void setupSdkPaths(@NotNull Sdk sdk) {
String homePath = sdk.getHomePath();
assert homePath != null : sdk;
File jdkHome = new File(homePath);
List<VirtualFile> classes = findClasses(jdkHome, false);
VirtualFile sources = findSources(jdkHome);
VirtualFile docs = findDocs(jdkHome, "docs/api");
SdkModificator sdkModificator = sdk.getSdkModificator();
Set<VirtualFile> previousRoots =
new LinkedHashSet<>(Arrays.asList(sdkModificator.getRoots(OrderRootType.CLASSES)));
sdkModificator.removeRoots(OrderRootType.CLASSES);
previousRoots.removeAll(new HashSet<>(classes));
for (VirtualFile aClass : classes) {
sdkModificator.addRoot(aClass, OrderRootType.CLASSES);
}
for (VirtualFile root : previousRoots) {
sdkModificator.addRoot(root, OrderRootType.CLASSES);
}
if (sources != null) {
sdkModificator.addRoot(sources, OrderRootType.SOURCES);
}
VirtualFile javaFxSources = findSources(jdkHome, "javafx-src");
if (javaFxSources != null) {
sdkModificator.addRoot(javaFxSources, OrderRootType.SOURCES);
}
if (docs != null) {
sdkModificator.addRoot(docs, JavadocOrderRootType.getInstance());
} else if (SystemInfo.isMac) {
VirtualFile commonDocs = findDocs(jdkHome, "docs");
if (commonDocs == null) {
commonDocs = findInJar(new File(jdkHome, "docs.jar"), "doc/api");
if (commonDocs == null) {
commonDocs = findInJar(new File(jdkHome, "docs.jar"), "docs/api");
}
}
if (commonDocs != null) {
sdkModificator.addRoot(commonDocs, JavadocOrderRootType.getInstance());
}
VirtualFile appleDocs = findDocs(jdkHome, "appledocs");
if (appleDocs == null) {
appleDocs = findInJar(new File(jdkHome, "appledocs.jar"), "appledoc/api");
}
if (appleDocs != null) {
sdkModificator.addRoot(appleDocs, JavadocOrderRootType.getInstance());
}
if (commonDocs == null && appleDocs == null && sources == null) {
String url = getDefaultDocumentationUrl(sdk);
if (url != null) {
sdkModificator.addRoot(
VirtualFileManager.getInstance().findFileByUrl(url),
JavadocOrderRootType.getInstance());
}
}
} else if (getVersion(sdk) == JavaSdkVersion.JDK_1_7) {
VirtualFile url =
VirtualFileManager.getInstance().findFileByUrl("http://docs.oracle.com/javafx/2/api/");
sdkModificator.addRoot(url, JavadocOrderRootType.getInstance());
}
attachJdkAnnotations(sdkModificator);
sdkModificator.commitChanges();
}
/**
* Goal-driven recursive (depth-first, exhaustive) search with backtracking
*
* @param problem
* @param algorithm
* @param subtaskRelsInPath
* @param depth
*/
private boolean subtaskPlanningImpl(
PlanningContext context,
Set<Rel> relsWithSubtasks,
EvaluationAlgorithm algorithm,
LinkedList<Rel> subtaskRelsInPath,
int depth) {
Set<Rel> relsWithSubtasksCopy = new LinkedHashSet<Rel>(relsWithSubtasks);
Set<Rel> relsWithSubtasksToRemove = new LinkedHashSet<Rel>();
boolean firstMLB = true;
// start building Maximal Linear Branch (MLB)
MLB:
while (!relsWithSubtasksCopy.isEmpty()) {
if (isSubtaskLoggingOn()) {
String print = p(depth) + "Starting new MLB with: ";
for (Rel rel : relsWithSubtasksCopy) {
print +=
"\n" + p(depth) + " " + rel.getParent().getFullName() + " : " + rel.getDeclaration();
}
/*
print += "\n" + p( depth ) + " All remaining rels in problem:";
for ( Rel rel : problem.getAllRels() ) {
print += "\n" + p( depth ) + " " + rel.getParentObjectName() + " : " + rel.getDeclaration();
}
print += "\n" + p( depth ) + "All found variables: ";
for ( Var var : problem.getFoundVars() ) {
print += "\n" + p( depth ) + " " + var.toString();
}
*/
logger.debug(print);
}
// if this is a first attempt to construct an MLB to solve a subtask(i.e. depth>0),
// do not invoke linear planning because it has already been done
if ((depth == 0) || !firstMLB) {
boolean solvedIntermediately = linearForwardSearch(context, algorithm, true);
// Having constructed some MLBs the (sub)problem may be solved
// and there is no need in wasting precious time planning unnecessary branches
if (solvedIntermediately
&& ( // on the top level optimize only if computing goals
(depth == 0 && !computeAll)
// otherwise (inside subtasks) always optimize
|| (depth != 0))) {
// If the problem is solved, optimize and return
if (!isOptDisabled) Optimizer.optimize(context, algorithm);
return true;
}
} else {
firstMLB = false;
}
// or children
OR:
for (Iterator<Rel> subtaskRelIterator = relsWithSubtasksCopy.iterator();
subtaskRelIterator.hasNext(); ) {
Rel subtaskRel = subtaskRelIterator.next();
if (isSubtaskLoggingOn())
logger.debug(
p(depth)
+ "OR: depth: "
+ (depth + 1)
+ " rel - "
+ subtaskRel.getParent().getFullName()
+ " : "
+ subtaskRel.getDeclaration());
if (subtaskRel.equals(subtaskRelsInPath.peekLast())
|| (!context.isRelReadyToUse(subtaskRel))
|| context.getFoundVars().containsAll(subtaskRel.getOutputs())
|| (!isSubtaskRepetitionAllowed && subtaskRelsInPath.contains(subtaskRel))) {
if (isSubtaskLoggingOn()) {
logger.debug(p(depth) + "skipped");
if (!context.isRelReadyToUse(subtaskRel)) {
logger.debug(p(depth) + "because it has unknown inputs"); // TODO print unknown
} else if (context.getFoundVars().containsAll(subtaskRel.getOutputs())) {
logger.debug(p(depth) + "because all outputs in FoundVars");
} else if (subtaskRel.equals(subtaskRelsInPath.peekLast())) {
logger.debug(p(depth) + "because it is nested in itself");
} else if (!isSubtaskRepetitionAllowed && subtaskRelsInPath.contains(subtaskRel)) {
logger.debug(
p(depth)
+ "This rel with subtasks is already in use, path: "
+ subtaskRelsInPath);
}
}
continue OR;
}
LinkedList<Rel> newPath = new LinkedList<Rel>(subtaskRelsInPath);
newPath.add(subtaskRel);
PlanningResult result = new PlanningResult(subtaskRel, true);
// this is true if all subtasks are solvable
boolean allSolved = true;
// and children
AND:
for (SubtaskRel subtask : subtaskRel.getSubtasks()) {
if (isSubtaskLoggingOn()) logger.debug(p(depth) + "AND: subtask - " + subtask);
EvaluationAlgorithm sbtAlgorithm = null;
////////////////////// INDEPENDENT SUBTASK////////////////////////////////////////
if (subtask.isIndependent()) {
if (isSubtaskLoggingOn()) logger.debug("Independent!!!");
if (subtask.isSolvable() == null) {
if (isSubtaskLoggingOn())
logger.debug("Start solving independent subtask " + subtask.getDeclaration());
// independent subtask is solved only once
Problem problemContext = subtask.getContext();
DepthFirstPlanner planner = new DepthFirstPlanner();
planner.indSubtasks = indSubtasks;
planner.nested = true;
sbtAlgorithm = planner.invokePlaning(problemContext, isOptDisabled);
PlanningContext indCntx = problemContext.getCurrentContext();
boolean solved = indCntx.getFoundVars().containsAll(indCntx.getAllGoals());
if (solved) {
subtask.setSolvable(Boolean.TRUE);
indSubtasks.put(subtask, sbtAlgorithm);
if (isSubtaskLoggingOn()) logger.debug("Solved " + subtask.getDeclaration());
} else {
subtask.setSolvable(Boolean.FALSE);
if (RuntimeProperties.isLogInfoEnabled()) {
logger.debug("Unable to solve " + subtask.getDeclaration());
}
}
allSolved &= solved;
} else if (subtask.isSolvable() == Boolean.TRUE) {
if (isSubtaskLoggingOn()) logger.debug("Already solved");
allSolved &= true;
sbtAlgorithm = indSubtasks.get(subtask);
} else {
if (isSubtaskLoggingOn()) logger.debug("Not solvable");
allSolved &= false;
}
if (isSubtaskLoggingOn()) logger.debug("End of independent subtask " + subtask);
if (!allSolved) {
continue OR;
}
assert sbtAlgorithm != null;
result.addSubtaskAlgorithm(subtask, sbtAlgorithm);
}
////////////////////// DEPENDENT SUBTASK//////////////////////////////////////
else {
// lets clone the environment
PlanningContext newContext = prepareNewContext(context, subtask);
sbtAlgorithm = new EvaluationAlgorithm();
// during linear planning, if some goals are found, they are removed from the set
// "goals"
boolean solved =
linearForwardSearch(
newContext,
sbtAlgorithm,
// do not optimize here, because the solution may require additional rels with
// subtasks
true);
if (solved) {
if (isSubtaskLoggingOn()) logger.debug(p(depth) + "SOLVED subtask: " + subtask);
if (!isOptDisabled) {
// if a subtask has been solved, optimize its algorithm
Optimizer.optimize(newContext, sbtAlgorithm);
}
result.addSubtaskAlgorithm(subtask, sbtAlgorithm);
allSolved &= solved;
continue AND;
} else if (!solved && (depth == maxDepth)) {
if (isSubtaskLoggingOn())
logger.debug(p(depth) + "NOT SOLVED and cannot go any deeper, subtask: " + subtask);
continue OR;
}
if (isSubtaskLoggingOn()) logger.debug(p(depth) + "Recursing deeper");
solved =
subtaskPlanningImpl(newContext, relsWithSubtasks, sbtAlgorithm, newPath, depth + 1);
if (isSubtaskLoggingOn()) logger.debug(p(depth) + "Back to depth " + (depth + 1));
// the linear planning has been performed at the end of MLB on the depth+1,
// if the problem was solved, there is no need to run linear planning again
if ((solved || (solved = linearForwardSearch(newContext, sbtAlgorithm, true)))
&& !isOptDisabled) {
// if solved, optimize here with full list of goals in order to get rid of
// unnecessary subtask instances and other relations
Optimizer.optimize(newContext, sbtAlgorithm);
}
if (isSubtaskLoggingOn())
logger.debug(p(depth) + (solved ? "" : "NOT") + " SOLVED subtask: " + subtask);
allSolved &= solved;
// if at least one subtask is not solvable, try another
// branch
if (!allSolved) {
continue OR;
}
result.addSubtaskAlgorithm(subtask, sbtAlgorithm);
}
} // AND
if (allSolved) {
algorithm.add(result);
Set<Var> newVars = new LinkedHashSet<Var>();
unfoldVarsToSet(subtaskRel.getOutputs(), newVars);
context.getKnownVars().addAll(newVars);
context.getFoundVars().addAll(newVars);
subtaskRelIterator.remove();
if (isSubtaskLoggingOn()) {
logger.debug(
p(depth)
+ "SOLVED ALL SUBTASKS for "
+ subtaskRel.getParent().getFullName()
+ " : "
+ subtaskRel.getDeclaration());
logger.debug(p(depth) + "Updating the problem graph and continuing building new MLB");
}
// this is used for incremental dfs
if (depth == 0) {
relsWithSubtasksToRemove.add(subtaskRel);
}
continue MLB;
}
if (isSubtaskLoggingOn())
logger.debug(
p(depth)
+ "NOT SOLVED ALL subtasks, removing from path "
+ subtaskRel.getParent().getFullName()
+ " : "
+ subtaskRel.getDeclaration());
newPath.remove(subtaskRel);
} // end OR
// exit loop because there are no more rels with subtasks to be
// applied
// (i.e. no more rels can introduce new variables into the
// algorithm)
if (isSubtaskLoggingOn()) logger.debug(p(depth) + "No more MLB can be constructed");
break MLB;
}
// incremental dfs, remove solved subtasks
if (depth == 0) {
relsWithSubtasks.removeAll(relsWithSubtasksToRemove);
}
return false;
}
public boolean execute() {
if (CDState.getCycle() % period != 0) return false;
MycoCast mycocast = (MycoCast) Network.get(0).getProtocol(mycocastPid);
int bio = mycocast.countBiomass();
int ext = mycocast.countExtending();
int bra = mycocast.countBranching();
int imm = mycocast.countImmobile();
// Update vertices
Set<MycoNode> activeNodes = new HashSet<MycoNode>();
for (int i = 0; i < Network.size(); i++) {
MycoNode n = (MycoNode) Network.get(i);
activeNodes.add(n);
HyphaData data = n.getHyphaData();
// if (data.isBiomass()) { continue; }
if (graph.containsVertex(n)) {
graph.removeVertex(n);
}
if (!graph.containsVertex(n)) {
graph.addVertex(n);
}
}
Set<MycoNode> jungNodes = new HashSet<MycoNode>(graph.getVertices());
jungNodes.removeAll(activeNodes);
for (MycoNode n : jungNodes) {
graph.removeVertex(n);
}
// Update edges
for (int i = 0; i < Network.size(); i++) {
MycoNode n = (MycoNode) Network.get(i);
HyphaData data = n.getHyphaData();
HyphaLink link = n.getHyphaLink();
synchronized (graph) {
// We now add in all links and tune out display in Visualizer
java.util.List<MycoNode> neighbors = (java.util.List<MycoNode>) link.getNeighbors();
//// Adding only links to hypha thins out links to biomass
// (java.util.List<MycoNode>) link.getHyphae();
Collection<MycoNode> jungNeighbors = graph.getNeighbors(n);
// Remove edges from Jung graph that are not in peersim graph
for (MycoNode o : jungNeighbors) {
if (!neighbors.contains(o)) {
MycoEdge edge = graph.findEdge(n, o);
while (edge != null) {
graph.removeEdge(edge);
edge = graph.findEdge(n, o);
}
}
}
// Add missing edges to Jung graph that are in peersim graph
for (MycoNode o : neighbors) {
if (graph.findEdge(n, o) == null) {
MycoEdge edge = new MycoEdge();
graph.addEdge(edge, n, o, EdgeType.DIRECTED);
}
}
}
// log.finest("VERTICES: " + graph.getVertices());
// log.finest("EDGES: " + graph.getEdges());
}
for (ChangeListener cl : changeListeners) {
cl.stateChanged(new ChangeEvent(graph));
}
if (walking) {
try {
Thread.sleep(walkDelay);
} catch (InterruptedException e) {
}
stepBlocked = false;
}
try {
while (stepBlocked && !noBlock) {
synchronized (JungGraphObserver.class) {
JungGraphObserver.class.wait();
}
}
} catch (InterruptedException e) {
stepBlocked = true;
}
stepBlocked = true;
// System.out.println(graph.toString());
return false;
}
