@Override public int compare(java.util.Map.Entry<CsmProject, SortedName> o1, java.util.Map.Entry<CsmProject, SortedName> o2) { if (o1.getKey().isArtificial() != o2.getKey().isArtificial()){ return o1.getKey().isArtificial()?1:-1; } return o1.getValue().compareTo(o2.getValue()); } }
private static ProjectBase searchInProjectFilesArtificial(List<CsmProject> libraries, ResolvedPath searchFor, Set<ProjectBase> antiLoop) { for (CsmProject prj : libraries) { if (prj.isArtificial()) { antiLoop.clear(); ProjectBase res = searchInProjectFiles((ProjectBase) prj, searchFor, antiLoop); if (res != null) { return res; } } } return null; }
@Override public String getProjectName() { CharSequence prjName = project.getName(); if (project.isArtificial()) { prjName = CsmDisplayUtilities.shrinkPath(prjName, 32, 2, 2); } return prjName.toString(); }
private void processProjectLibs(CsmProject project, CsmSelect.CsmFilter filter, Set<CsmProject> processedLibs, NameMatcher matcher) { for (CsmProject lib : project.getLibraries()) { checkCancelled(); if (lib.isArtificial()) { if (!processedLibs.contains(lib)) { processedLibs.add(lib); processProject(lib, filter, matcher); } } } }
public ProjectNode(final CsmProject project, Children.Array key) { super(key, Lookups.fixed(project)); this.project = project; isLibrary = project.isArtificial(); init(project); }
public static ImageIcon getProjectIcon(CsmProject prj, boolean opened) { String iconPath = getProjectPath(prj.isArtificial(), opened); return getCachedImageIcon(iconPath); }
/** * Collects projects to find specialization in * * @param contextFile - start file * * @return list of projects. First element in the list is the project which contains start file */ private List<ProjectBase> collectProjects(CsmFile contextFile) { List<ProjectBase> projects = new ArrayList<>(4); CsmProject project = contextFile.getProject(); if (project instanceof ProjectBase) { projects.add((ProjectBase) project); } if (project != null && !project.isArtificial()) { for (CsmProject libProject : project.getLibraries()) { if (libProject instanceof ProjectBase) { projects.add((ProjectBase) libProject); } } } return projects; }
public void openProject(CsmProject project) { if (project.isArtificial()) { if (libOwnerProject == null) { return; } else if (!libOwnerProject.getLibraries().contains(project)) { return; } } synchronized(myProjectsLock) { if (myProjects == null) { return; } for(java.util.Map.Entry<CsmProject,SortedName> entry : myProjects.entrySet()) { if (entry.getKey() instanceof DummyProject) { myProjects.clear(); break; } } if (myProjects.containsKey(project)) { return; } myProjects.put(project, getSortedName(project, false)); } resetKeys(); }
public static Collection<CsmProject> getSearchLibraries(CsmProject prj) { if (prj.isArtificial() && prj instanceof ProjectBase) { Set<CsmProject> libs = new HashSet<>(); for (ProjectBase projectBase : ((ProjectBase)prj).getDependentProjects()) { if (!projectBase.isArtificial()) { libs.addAll(projectBase.getLibraries()); } } return libs; } else { return prj.getLibraries(); } }
private static ProjectBase searchInProjectRootsArtificial(List<CsmProject> libraries, FileSystem fs, List<CharSequence> folders, Set<ProjectBase> set) { ProjectBase candidate = null; for (CsmProject prj : libraries) { if (prj.isArtificial()) { set.clear(); ProjectBase res = searchInProjectRoots((ProjectBase) prj, fs, folders, set); if (res != null) { if (candidate == null) { candidate = res; } else { CharSequence path1 = ((LibProjectImpl)candidate).getPath(); CharSequence path2 = ((LibProjectImpl)res).getPath(); if (path2.length() > path1.length()) { candidate = res; } } } } } return candidate; }
public NamespaceKeyArray(ChildrenUpdater childrenUpdater, CsmProject project){ super(childrenUpdater, project, PersistentKey.createGlobalNamespaceKey(project)); if (!project.isArtificial()) { CsmListeners.getDefault().addProgressListener(this); isRootNamespase = true; } }
private Collection<CsmProject> getLibraries(CsmFile file, int contextOffset) { CsmProject project = file.getProject(); if (project == null) { return Collections.emptyList(); } if (project.isArtificial()) { Collection<CsmProject> out = new HashSet<>(2); for (CsmCompilationUnit cu : CsmFileInfoQuery.getDefault().getCompilationUnits(file, contextOffset)) { out.addAll(cu.getStartProject().getLibraries()); } return out; } else { return project.getLibraries(); } } }
private static ProjectBase searchInProjectRoots(ProjectBase baseProject, FileSystem fs, List<CharSequence> folders, Set<ProjectBase> set) { if (set.contains(baseProject)) { return null; } set.add(baseProject); if (baseProject.getFileSystem() == fs) { for (CharSequence folder : folders) { if (baseProject.isMySource(folder)) { return baseProject; } } } List<CsmProject> libraries = baseProject.getLibraries(); for (CsmProject prj : libraries) { if (prj.isArtificial()) { break; } ProjectBase res = searchInProjectRoots((ProjectBase) prj, fs, folders, set); if (res != null) { return res; } } return null; }
public NamespaceKeyArray(ChildrenUpdater childrenUpdater, CsmNamespace namespace){ super(childrenUpdater, namespace.getProject(),PersistentKey.createKey(namespace)); CsmProject project = namespace.getProject(); if (namespace.equals(project.getGlobalNamespace())){ if (!project.isArtificial()) { CsmListeners.getDefault().addProgressListener(this); isRootNamespase = true; } } }
@Override public void fileAddedToParse(CsmFile file) { CsmProject project = file.getProject(); ParsingProgress handle = getHandle(project, false); if (handle != null) { handle.addedToParse(file); } else if (project.isArtificial()) { for (CsmProject p : CsmModelAccessor.getModel().projects()){ if (!p.isArtificial()) { if (p.getLibraries().contains(project)){ handle = getHandle(p, false); if (handle != null) { handle.addedToParse(file); } } } } } }
@Override public void fileParsingStarted(CsmFile file) { if (TraceFlags.TRACE_PARSER_QUEUE) { System.err.println(" ProgressListenerImpl.fileParsingStarted " + file.getAbsolutePath()); } CsmProject project = file.getProject(); ParsingProgress handle = getHandle(project, false); if (handle != null) { handle.nextCsmFile(file); } else if (project.isArtificial()) { for (CsmProject p : CsmModelAccessor.getModel().projects()){ if (!p.isArtificial()) { if (p.getLibraries().contains(project)){ handle = getHandle(p, false); if (handle != null) { handle.nextCsmFile(file); } } } } } }
private static ProjectBase searchInProjectFiles(ProjectBase baseProject, ResolvedPath searchFor, Set<ProjectBase> set) { if (set.contains(baseProject)) { return null; } set.add(baseProject); if (baseProject.getFileSystem() == searchFor.getFileSystem()) { baseProject.ensureFilesCreated(); CsmUID<CsmFile> file = baseProject.getFileUID(searchFor.getPath(), true); if (file != null) { return baseProject; } } List<CsmProject> libraries = baseProject.getLibraries(); for (CsmProject prj : libraries) { if (prj.isArtificial()) { break; } ProjectBase res = searchInProjectFiles((ProjectBase) prj, searchFor, set); if (res != null) { return res; } } return null; }
protected CsmProjectContentResolver createContentResolver() { CsmFile contextFile = this.file; CsmProject filePrj = contextFile.getProject(); CsmProject startProject = filePrj; CsmFile startProjectFile = this.file; Collection<CsmProject> libs = new ArrayList<CsmProject>(); boolean replaceProject = startProject.isArtificial(); for (CsmCompilationUnit cu : CsmFileInfoQuery.getDefault().getCompilationUnits(file, contextOffset)) { CsmFile startFile = cu.getStartFile(); CsmProject prj = startFile == null ? null : startFile.getProject(); if (prj != null) { startProject = replaceProject ? prj : startProject; startProjectFile = startFile; break; } } // add libararies elements libs.addAll(startProject.getLibraries()); CsmProjectContentResolver resolver = new CsmProjectContentResolver(startProjectFile, filePrj, isCaseSensitive(), isSortNeeded(), isNaturalSort(), libs); return resolver; }
@Override public CsmClassifier getOriginalClassifier(CsmClassifier orig, CsmFile contextFile) { if (orig instanceof CsmOffsetable) { CsmProject project = contextFile.getProject(); // we'd prefer to start from real project, not artificial one if (project != null && project.isArtificial()) { for (CsmCompilationUnit cu : CsmFileInfoQuery.getDefault().getCompilationUnits(contextFile, 0)) { if (cu.getStartFile() != null) { contextFile = cu.getStartFile(); break; } } } Resolver aResolver = ResolverFactory.createResolver((CsmOffsetable) orig, contextFile); try { return aResolver.getOriginalClassifier(orig); } finally { ResolverFactory.releaseResolver(aResolver); } } return orig; }
@Override public CsmClassifier getTypeClassifier(CsmType type, CsmFile contextFile, int contextOffset, boolean resolveTypeChain) { CsmProject project = contextFile.getProject(); // we'd prefer to start from real project, not artificial one if (project != null && project.isArtificial()) { for (CsmCompilationUnit cu : CsmFileInfoQuery.getDefault().getCompilationUnits(contextFile, contextOffset)) { if (cu.getStartFile() != null) { contextFile = cu.getStartFile(); break; } } } Resolver resolver = ResolverFactory.createResolver(contextFile, contextOffset); CsmClassifier cls = null; try { cls = type.getClassifier(); if (resolveTypeChain) { cls = resolver.getOriginalClassifier(cls); } } finally { ResolverFactory.releaseResolver(resolver); } return cls; }