public Set<E> getAllEdges(V sourceVertex, V targetVertex) { Set<E> res = new HashSet<E>(); if (g1.containsVertex(sourceVertex) && g1.containsVertex(targetVertex)) { res.addAll(g1.getAllEdges(sourceVertex, targetVertex)); } if (g2.containsVertex(sourceVertex) && g2.containsVertex(targetVertex)) { res.addAll(g2.getAllEdges(sourceVertex, targetVertex)); } return Collections.unmodifiableSet(res); }
public Set<E> edgesOf(V vertex) { Set<E> res = new HashSet<E>(); if (g1.containsVertex(vertex)) { res.addAll(g1.edgesOf(vertex)); } if (g2.containsVertex(vertex)) { res.addAll(g2.edgesOf(vertex)); } return Collections.unmodifiableSet(res); }
protected void buildMaps(PegGraph pg) { exceHandlers.addAll(pg.getExceHandlers()); startToThread.putAll(pg.getStartToThread()); startToAllocNodes.putAll(pg.getStartToAllocNodes()); startToBeginNodes.putAll(pg.getStartToBeginNodes()); waitingNodes.putAll(pg.getWaitingNodes()); notifyAll.putAll(pg.getNotifyAll()); canNotBeCompacted.addAll(pg.getCanNotBeCompacted()); synch.addAll(pg.getSynch()); threadNameToStart.putAll(pg.getThreadNameToStart()); specialJoin.addAll(pg.getSpecialJoin()); joinStmtToThread.putAll(pg.getJoinStmtToThread()); threadAllocSites.addAll(pg.getThreadAllocSites()); allocNodeToThread.putAll(pg.getAllocNodeToThread()); }
private static List<String> calcVCFGenotypeKeys(VariantContext vc) { Set<String> keys = new HashSet<String>(); boolean sawGoodGT = false; boolean sawGoodQual = false; boolean sawGenotypeFilter = false; for (Genotype g : vc.getGenotypes().values()) { keys.addAll(g.getAttributes().keySet()); if (g.isAvailable()) sawGoodGT = true; if (g.hasNegLog10PError()) sawGoodQual = true; if (g.isFiltered() && g.isCalled()) sawGenotypeFilter = true; } if (sawGoodQual) keys.add(VCFConstants.GENOTYPE_QUALITY_KEY); if (sawGenotypeFilter) keys.add(VCFConstants.GENOTYPE_FILTER_KEY); List<String> sortedList = ParsingUtils.sortList(new ArrayList<String>(keys)); // make sure the GT is first if (sawGoodGT) { List<String> newList = new ArrayList<String>(sortedList.size() + 1); newList.add(VCFConstants.GENOTYPE_KEY); newList.addAll(sortedList); sortedList = newList; } return sortedList; }
/** * Notifies this <tt>Conference</tt> that the ordered list of <tt>Endpoint</tt>s of {@link * #speechActivity} i.e. the dominant speaker history has changed. * * <p>This instance notifies the video <tt>Channel</tt>s about the change so that they may update * their last-n lists and report to this instance which <tt>Endpoint</tt>s are to be asked for * video keyframes. */ private void speechActivityEndpointsChanged() { List<Endpoint> endpoints = null; for (Content content : getContents()) { if (MediaType.VIDEO.equals(content.getMediaType())) { Set<Endpoint> endpointsToAskForKeyframes = null; endpoints = speechActivity.getEndpoints(); for (Channel channel : content.getChannels()) { if (!(channel instanceof RtpChannel)) continue; RtpChannel rtpChannel = (RtpChannel) channel; List<Endpoint> channelEndpointsToAskForKeyframes = rtpChannel.speechActivityEndpointsChanged(endpoints); if ((channelEndpointsToAskForKeyframes != null) && !channelEndpointsToAskForKeyframes.isEmpty()) { if (endpointsToAskForKeyframes == null) { endpointsToAskForKeyframes = new HashSet<>(); } endpointsToAskForKeyframes.addAll(channelEndpointsToAskForKeyframes); } } if ((endpointsToAskForKeyframes != null) && !endpointsToAskForKeyframes.isEmpty()) { content.askForKeyframes(endpointsToAskForKeyframes); } } } }
private Set<Vertex> computeMinVertexCover(Set<Vertex> side1, Set<Vertex> side2) { Set<Vertex> konigSet = new HashSet<Vertex>(); Set<Vertex> unmatched = new TreeSet<Vertex>(side1); unmatched.removeAll(matches); // System.out.println("Matches: " + matches); // System.out.println("side 1 unmatched set: " + unmatched); for (Vertex v : unmatched) { konigDFS(konigSet, v, false); } // System.out.println("Konig set: " + konigSet); Set<Vertex> result = new HashSet<Vertex>(side2); result.retainAll(konigSet); // System.out.println("side 2 intersect konigSet: " + result); Set<Vertex> side1notInKonigSet = new HashSet<Vertex>(side1); side1notInKonigSet.removeAll(konigSet); // System.out.println("side 1 not in Konig set: " + side1notInKonigSet); result.addAll(side1notInKonigSet); return result; }
/** Performs peephole optimizations on a program's live methods. */ private static void peephole(final BloatContext context) { final Set liveMethods = new TreeSet(new MemberRefComparator()); final CallGraph cg = context.getCallGraph(); liveMethods.addAll(cg.liveMethods()); // Perform peephole optimizations. We do this separately because // some peephole optimizations do things to the stack that // inlining doesn't like. For instance, a peephole optimizations // might make it so that a method has a non-empty stack upon // return. Inlining will barf at the sight of this. BloatBenchmark.tr("Performing peephole optimizations"); final Iterator iter = liveMethods.iterator(); while (BloatBenchmark.PEEPHOLE && iter.hasNext()) { try { final MethodEditor live = context.editMethod((MemberRef) iter.next()); Peephole.transform(live); context.commit(live.methodInfo()); context.release(live.methodInfo()); } catch (final NoSuchMethodException ex314) { BloatBenchmark.err.println("** Could not find method " + ex314.getMessage()); ex314.printStackTrace(System.err); System.exit(1); } } }
@SuppressWarnings("static-method") public Map<String, Object> processOperations( CodegenConfig config, String tag, List<CodegenOperation> ops) { Map<String, Object> operations = new HashMap<String, Object>(); Map<String, Object> objs = new HashMap<String, Object>(); objs.put("classname", config.toApiName(tag)); objs.put("pathPrefix", config.toApiVarName(tag)); // check for operationId uniqueness Set<String> opIds = new HashSet<String>(); int counter = 0; for (CodegenOperation op : ops) { String opId = op.nickname; if (opIds.contains(opId)) { counter++; op.nickname += "_" + counter; } opIds.add(opId); } objs.put("operation", ops); operations.put("operations", objs); operations.put("package", config.apiPackage()); Set<String> allImports = new LinkedHashSet<String>(); for (CodegenOperation op : ops) { allImports.addAll(op.imports); } List<Map<String, String>> imports = new ArrayList<Map<String, String>>(); for (String nextImport : allImports) { Map<String, String> im = new LinkedHashMap<String, String>(); String mapping = config.importMapping().get(nextImport); if (mapping == null) { mapping = config.toModelImport(nextImport); } if (mapping != null) { im.put("import", mapping); imports.add(im); } } operations.put("imports", imports); // add a flag to indicate whether there's any {{import}} if (imports.size() > 0) { operations.put("hasImport", true); } config.postProcessOperations(operations); if (objs.size() > 0) { List<CodegenOperation> os = (List<CodegenOperation>) objs.get("operation"); if (os != null && os.size() > 0) { CodegenOperation op = os.get(os.size() - 1); op.hasMore = null; } } return operations; }
private Set<Document> getDocsWithAnyEmotions( Indexer indexer, Collection<Document> docs, boolean originalContentOnly) { Set<Document> result = new LinkedHashSet<Document>(); // return all docs that have at least one sentiment Map<String, Collection<Document>> map = getEmotions(indexer, docs, originalContentOnly, false); for (Collection<Document> values : map.values()) result.addAll(values); return result; }
private Set<String> getDownstream(String mut) { Set<String> tfs = new HashSet<String>(); tfs.add(mut); if (depth > 1) tfs.addAll(travSt.getDownstream(tfs, depth - 1)); return travExp.getDownstream(tfs); }
public static Set<RepairedCell> getRepairFalse(Set<RepairedCell> truth, Set<RepairedCell> found) { Set<RepairedCell> rst = new HashSet<RepairedCell>(); if (found.size() != 0) { rst.addAll(found); rst.removeAll(truth); } return rst; }
private static Set<String> nextLevelOfWords(final Set<String> current, final List<String> dict) { Set<String> next = new TreeSet<String>(); for (String word : current) { next.addAll(wordLadder(word, dict)); } return next; }
/** Send merkle tree request to every involved neighbor. */ public void sendTreeRequests() { requestedEndpoints.addAll(endpoints); requestedEndpoints.add(FBUtilities.getLocalAddress()); // send requests to all nodes for (InetAddress endpoint : requestedEndpoints) AntiEntropyService.instance.request(getName(), endpoint, range, tablename, cfname); }
/** Gets all Genomic Data. */ private ProfileDataSummary getGenomicData( String cancerStudyId, HashMap<String, GeneticProfile> defaultGeneticProfileSet, SampleList defaultSampleSet, String geneListStr, ArrayList<SampleList> sampleList, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException, DaoException { // parse geneList, written in the OncoPrintSpec language (except for changes by XSS clean) double zScore = ZScoreUtil.getZScore( new HashSet<String>(defaultGeneticProfileSet.keySet()), new ArrayList<GeneticProfile>(defaultGeneticProfileSet.values()), request); double rppaScore = ZScoreUtil.getRPPAScore(request); ParserOutput theOncoPrintSpecParserOutput = OncoPrintSpecificationDriver.callOncoPrintSpecParserDriver( geneListStr, new HashSet<String>(defaultGeneticProfileSet.keySet()), new ArrayList<GeneticProfile>(defaultGeneticProfileSet.values()), zScore, rppaScore); ArrayList<String> geneList = new ArrayList<String>(); geneList.addAll(theOncoPrintSpecParserOutput.getTheOncoPrintSpecification().listOfGenes()); ArrayList<ProfileData> profileDataList = new ArrayList<ProfileData>(); Set<String> warningUnion = new HashSet<String>(); for (GeneticProfile profile : defaultGeneticProfileSet.values()) { try { GetProfileData remoteCall = new GetProfileData( profile, geneList, StringUtils.join(defaultSampleSet.getSampleList(), " ")); ProfileData pData = remoteCall.getProfileData(); warningUnion.addAll(remoteCall.getWarnings()); profileDataList.add(pData); } catch (IllegalArgumentException e) { e.getStackTrace(); } } ProfileMerger merger = new ProfileMerger(profileDataList); ProfileData mergedProfile = merger.getMergedProfile(); ProfileDataSummary dataSummary = new ProfileDataSummary( mergedProfile, theOncoPrintSpecParserOutput.getTheOncoPrintSpecification(), zScore, rppaScore); return dataSummary; }
/** * Get a list of all the TdbAu.Ids for this Tdb * * @return a collection of TdbAu objects */ public Set<TdbAu.Id> getAllTdbAuIds() { if (pluginIdTdbAuIdsMap == null) { return Collections.<TdbAu.Id>emptySet(); } Set<TdbAu.Id> allAuIds = new HashSet<TdbAu.Id>(); // For each plugin's AU set, add them all to the set. for (Collection<TdbAu.Id> auIds : pluginIdTdbAuIdsMap.values()) { allAuIds.addAll(auIds); } return allAuIds; }
static String[] getOrderedEdgeLabels(Graph g) { Set labelSet = new HashSet(); for (Iterator i = g.getNodeIterator(); i.hasNext(); ) { GraphId id = (GraphId) i.next(); labelSet.addAll(g.getEdgeLabels(id)); } log.debug(labelSet.size() + " labels in labelset."); String[] result = (String[]) labelSet.toArray(new String[labelSet.size()]); Arrays.sort(result); return result; }
public static Set<String> wordChain( final int steps, final List<String> current, final List<String> dict) { Set<String> finalSet = new TreeSet<String>(current); Set<String> next = nextLevelOfWords(finalSet, dict); for (int i = 0; i < steps; i++) { finalSet.addAll(next); next = nextLevelOfWords(next, dict); } return finalSet; }
// get signs using an additional arg for a target rel private Collection<Sign> getSignsFromPredAndTargetRel(String pred, String targetRel) { Collection<Word> words = (Collection<Word>) _predToWords.get(pred); String specialTokenConst = null; // for robustness, when using supertagger, add words for pred sans sense index int dotIndex = -1; if (_supertagger != null && !Character.isDigit(pred.charAt(0)) && // skip numbers (dotIndex = pred.lastIndexOf('.')) > 0 && pred.length() > dotIndex + 1 && pred.charAt(dotIndex + 1) != '_') // skip titles, eg Mr._Smith { String barePred = pred.substring(0, dotIndex); Collection<Word> barePredWords = (Collection<Word>) _predToWords.get(barePred); if (words == null) words = barePredWords; else if (barePredWords != null) { Set<Word> unionWords = new HashSet<Word>(words); unionWords.addAll(barePredWords); words = unionWords; } } if (words == null) { specialTokenConst = tokenizer.getSpecialTokenConstant(tokenizer.isSpecialToken(pred)); if (specialTokenConst == null) return null; // lookup words with pred = special token const Collection<Word> specialTokenWords = (Collection<Word>) _predToWords.get(specialTokenConst); // replace special token const with pred if (specialTokenWords == null) return null; words = new ArrayList<Word>(specialTokenWords.size()); for (Iterator<Word> it = specialTokenWords.iterator(); it.hasNext(); ) { Word stw = it.next(); Word w = Word.createSurfaceWord(stw, pred); words.add(w); } } List<Sign> retval = new ArrayList<Sign>(); for (Iterator<Word> it = words.iterator(); it.hasNext(); ) { Word w = it.next(); try { SignHash signs = getSignsFromWord(w, specialTokenConst, pred, targetRel); retval.addAll(signs.asSignSet()); } // shouldn't happen catch (LexException exc) { System.err.println("Unexpected lex exception for word " + w + ": " + exc); } } return retval; }
@Override protected void addIgnoreWords(String origLine, Set<String> wordsToBeIgnored) { String line; if (language.getShortNameWithCountryAndVariant().equals("de-CH")) { // hack: Swiss German doesn't use "ß" but always "ss" - replace this, otherwise // misspellings (from Swiss point-of-view) like "äußere" wouldn't be found: line = origLine.replace("ß", "ss"); } else { line = origLine; } wordsToBeIgnored.addAll(expandLine(line)); }
/* * XXX I hope this methos is not needed in this form */ public Map getKnownProjectsAndVersions(ICVSRepositoryLocation location) { Map knownTags = new HashMap(); RepositoryRoot root = getRepositoryRootFor(location); String[] paths = root.getKnownRemotePaths(); for (int i = 0; i < paths.length; i++) { String path = paths[i]; Set result = new HashSet(); result.addAll(Arrays.asList(root.getAllKnownTags(path))); knownTags.put(path, result); } return knownTags; }
/* returns set of terms for any of the given sentiments -- usually used for highlighting */ public Set<String> wordsForSentiments( Indexer indexer, Collection<Document> docs, String sentiments[]) { Map<String, String> captionToQueryMap = getCaptionToQueryMap(docs); if (sentiments == null) return null; Set<String> result = new LinkedHashSet<String>(); for (String sentiment : sentiments) { Set<String> set = wordsForSentiment(captionToQueryMap, sentiment); if (set == null) continue; result.addAll(set); } return result; }
Set<Artifact> getResolvedArtifactsFromUnresolvedDependencies( List<Dependency> unresolvedDependencies, boolean resolveTransitively) throws MojoExecutionException { final Set<Artifact> resolvedArtifacts = new HashSet<Artifact>(); // Artifact mojoArtifact = this.artifactFactory.createBuildArtifact(project.getGroupId(), // project.getArtifactId(), project.getVersion(), "pom"); /* * Resolve each artifact. This will get all transitive artifacts AND eliminate conflicts. */ final Set<Artifact> unresolvedArtifacts; // for (Dependency d : unresolvedDependencies) // System.out.println("dependency: " + d.toString()); try { unresolvedArtifacts = MavenMetadataSource.createArtifacts( this.artifactFactory, unresolvedDependencies, null, null, null); // for (Artifact artifact : unresolvedArtifacts) { // System.out.println("unresolved " + artifact.toString()); // } if (resolveTransitively) { ArtifactResolutionResult artifacts = artifactResolver.resolveTransitively( unresolvedArtifacts, project.getArtifact(), remoteRepositories, localRepository, artifactMetadataSource); resolvedArtifacts.addAll(artifacts.getArtifacts()); } else { // resolve each artifact individually for (Artifact artifact : unresolvedArtifacts) { artifactResolver.resolve(artifact, remoteRepositories, localRepository); resolvedArtifacts.add(artifact); } } } catch (Exception e) { throw new MojoExecutionException("Unable to complete configuring the build settings", e); } for (Artifact artifact : resolvedArtifacts) { System.out.println("matched " + artifact.toString()); } return resolvedArtifacts; }
/** * Prints a usage message to the given stream. * * @param out The output stream to write to. */ public void printUsage(Appendable out) { Formatter formatter = new Formatter(out); Set<CommandLineOption> orderedOptions = new TreeSet<CommandLineOption>(new OptionComparator()); orderedOptions.addAll(optionsByString.values()); Map<String, String> lines = new LinkedHashMap<String, String>(); for (CommandLineOption option : orderedOptions) { Set<String> orderedOptionStrings = new TreeSet<String>(new OptionStringComparator()); orderedOptionStrings.addAll(option.getOptions()); List<String> prefixedStrings = new ArrayList<String>(); for (String optionString : orderedOptionStrings) { if (optionString.length() == 1) { prefixedStrings.add("-" + optionString); } else { prefixedStrings.add("--" + optionString); } } String key = join(prefixedStrings, ", "); String value = option.getDescription(); if (value == null || value.length() == 0) { value = ""; } lines.put(key, value); } int max = 0; for (String optionStr : lines.keySet()) { max = Math.max(max, optionStr.length()); } for (Map.Entry<String, String> entry : lines.entrySet()) { if (entry.getValue().length() == 0) { formatter.format("%s%n", entry.getKey()); } else { formatter.format("%-" + max + "s %s%n", entry.getKey(), entry.getValue()); } } formatter.flush(); }
public static double repairAccuracy(Set<RepairedCell> truth, Set<RepairedCell> found) { if (found.size() != 0) { Set<RepairedCell> tAndF = new HashSet<RepairedCell>(); tAndF.addAll(truth); tAndF.retainAll(found); double precision = tAndF.size() * 1.0 / found.size(), recall = tAndF.size() * 1.0 / truth.size(); if (debug) System.out.println("repair precision = " + precision + ", repair recall = " + recall); return 2 * precision * recall / (precision + recall); } return 0; }
/** * Returns the live methods of a program whose root methods are the <tt>main</tt> method of a set * of classes. * * @param classes Names of classes containing root methods * @param context Repository for accessing BLOAT stuff * @return The <tt>MemberRef</tt>s of the live methods */ private static Collection liveMethods(final Collection classes, final BloatContext context) { // Determine the roots of the call graph final Set roots = new HashSet(); Iterator iter = classes.iterator(); while (iter.hasNext()) { final String className = (String) iter.next(); try { final ClassEditor ce = context.editClass(className); final MethodInfo[] methods = ce.methods(); for (int i = 0; i < methods.length; i++) { final MethodEditor me = context.editMethod(methods[i]); if (!me.name().equals("main")) { continue; } BloatBenchmark.tr(" Root " + ce.name() + "." + me.name() + me.type()); roots.add(me.memberRef()); } } catch (final ClassNotFoundException ex1) { BloatBenchmark.err.println("** Could not find class: " + ex1.getMessage()); System.exit(1); } } if (roots.isEmpty()) { BloatBenchmark.err.print("** No main method found in classes: "); iter = classes.iterator(); while (iter.hasNext()) { final String name = (String) iter.next(); BloatBenchmark.err.print(name); if (iter.hasNext()) { BloatBenchmark.err.print(", "); } } BloatBenchmark.err.println(""); } context.setRootMethods(roots); final CallGraph cg = context.getCallGraph(); final Set liveMethods = new TreeSet(new MemberRefComparator()); liveMethods.addAll(cg.liveMethods()); return (liveMethods); }
private Set<Artifact> collectAllProjectArtifacts() throws MojoExecutionException { final Set<Artifact> resolvedArtifacts = new HashSet<Artifact>(); /* * Get the Grails dependencies from the plugin's POM file first. */ final MavenProject pluginProject; try { pluginProject = getPluginProject(); } catch (ProjectBuildingException e) { throw new MojoExecutionException("Unable to get plugin project", e); } /* * Add the plugin's dependencies and the project using the plugin's dependencies to the list * of unresolved dependencies. This is done so they can all be resolved at the same time so * that we get the benefit of Maven's conflict resolution. */ Set<Artifact> uncheckedArtifacts = useTransitives ? resolveFromTree() : getResolvedArtifactsFromUnresolvedDependencies(project.getDependencies(), false); Map<String, Artifact> checklist = new HashMap<String, Artifact>(); for (Artifact artifact : uncheckedArtifacts) { // resolvedArtifacts.add(artifact); checklist.put(artifactToKey(artifact), artifact); // resolvedArtifacts.add(artifact); } // major breaking change, no dependencies from plugin /* for( Artifact artifact : getResolvedArtifactsFromUnresolvedDependencies(replaceVersion(filterGrailsDependencies(pluginProject.getDependencies())), true) ) { // resolvedArtifacts.add(artifact); String key = artifactToKey(artifact); Artifact existing = checklist.get(key); if (existing == null) checklist.put(key, artifact); } */ resolvedArtifacts.addAll(checklist.values()); return resolvedArtifacts; }
/** * Method getKnownTags. * * @param repository * @param set * @param i * @param monitor * @return CVSTag[] */ public CVSTag[] getKnownTags( ICVSRepositoryLocation repository, IWorkingSet set, int tagType, IProgressMonitor monitor) throws CVSException { if (set == null) { return getKnownTags(repository, tagType); } ICVSRemoteResource[] folders = getFoldersForTag(repository, CVSTag.DEFAULT, monitor); folders = filterResources(set, folders); Set tags = new HashSet(); for (int i = 0; i < folders.length; i++) { ICVSRemoteFolder folder = (ICVSRemoteFolder) folders[i]; tags.addAll(Arrays.asList(getKnownTags(folder, tagType))); } return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]); }
/** Specializes the live methods in a program. */ private static void specialize(final BloatContext context) { final CallGraph cg = context.getCallGraph(); final Set liveMethods = new TreeSet(new MemberRefComparator()); liveMethods.addAll(cg.liveMethods()); // Specialize all possible methods final InlineStats stats = context.getInlineStats(); if (BloatBenchmark.statsFile != null) { Specialize.STATS = true; stats.setConfigName("BloatBenchmark"); } if (BloatBenchmark.MORPH != -1) { Specialize.MAX_MORPH = BloatBenchmark.MORPH; } final Specialize spec = new Specialize(context); if (Specialize.STATS) { stats.noteLiveMethods(liveMethods.size()); stats.noteLiveClasses(cg.liveClasses().size()); } BloatBenchmark.tr("Specializing live methods"); final Iterator iter = liveMethods.iterator(); for (int count = 0; iter.hasNext(); count++) { try { final MethodEditor live = context.editMethod((MemberRef) iter.next()); if (context.ignoreMethod(live.memberRef())) { // Don't display ignored methods, it's misleading. continue; } BloatBenchmark.tr( " " + count + ") " + live.declaringClass().name() + "." + live.name() + live.type()); spec.specialize(live); } catch (final NoSuchMethodException ex2) { BloatBenchmark.err.println("** Could not find method " + ex2.getMessage()); System.exit(1); } } }
private void updateInSelectionHighlighters() { if (mySearchResults.getEditor() == null) return; final SelectionModel selectionModel = mySearchResults.getEditor().getSelectionModel(); int[] starts = selectionModel.getBlockSelectionStarts(); int[] ends = selectionModel.getBlockSelectionEnds(); final HashSet<RangeHighlighter> toRemove = new HashSet<RangeHighlighter>(); Set<RangeHighlighter> toAdd = new HashSet<RangeHighlighter>(); for (RangeHighlighter highlighter : myHighlighters) { boolean intersectsWithSelection = false; for (int i = 0; i < starts.length; ++i) { TextRange selectionRange = new TextRange(starts[i], ends[i]); intersectsWithSelection = selectionRange.intersects(highlighter.getStartOffset(), highlighter.getEndOffset()) && selectionRange.getEndOffset() != highlighter.getStartOffset() && highlighter.getEndOffset() != selectionRange.getStartOffset(); if (intersectsWithSelection) break; } final Object userData = highlighter.getUserData(IN_SELECTION_KEY); if (userData != null) { if (!intersectsWithSelection) { if (userData == IN_SELECTION2) { HighlightManager.getInstance(mySearchResults.getProject()) .removeSegmentHighlighter(mySearchResults.getEditor(), highlighter); toRemove.add(highlighter); } else { highlighter.putUserData(IN_SELECTION_KEY, null); } } } else if (intersectsWithSelection) { TextRange cursor = mySearchResults.getCursor(); if (cursor != null && highlighter.getStartOffset() == cursor.getStartOffset() && highlighter.getEndOffset() == cursor.getEndOffset()) continue; final RangeHighlighter toAnnotate = highlightRange( new TextRange(highlighter.getStartOffset(), highlighter.getEndOffset()), new TextAttributes(null, null, Color.WHITE, EffectType.ROUNDED_BOX, 0), toAdd); highlighter.putUserData(IN_SELECTION_KEY, IN_SELECTION1); toAnnotate.putUserData(IN_SELECTION_KEY, IN_SELECTION2); } } myHighlighters.removeAll(toRemove); myHighlighters.addAll(toAdd); }
@SuppressWarnings("static-method") public Map<String, Object> processModels( CodegenConfig config, Map<String, Model> definitions, Map<String, Model> allDefinitions) { Map<String, Object> objs = new HashMap<String, Object>(); objs.put("package", config.modelPackage()); List<Object> models = new ArrayList<Object>(); Set<String> allImports = new LinkedHashSet<String>(); for (String key : definitions.keySet()) { Model mm = definitions.get(key); CodegenModel cm = config.fromModel(key, mm, allDefinitions); Map<String, Object> mo = new HashMap<String, Object>(); mo.put("model", cm); mo.put("importPath", config.toModelImport(key)); models.add(mo); allImports.addAll(cm.imports); } objs.put("models", models); Set<String> importSet = new TreeSet<String>(); for (String nextImport : allImports) { String mapping = config.importMapping().get(nextImport); if (mapping == null) { mapping = config.toModelImport(nextImport); } if (mapping != null && !config.defaultIncludes().contains(mapping)) { importSet.add(mapping); } // add instantiation types mapping = config.instantiationTypes().get(nextImport); if (mapping != null && !config.defaultIncludes().contains(mapping)) { importSet.add(mapping); } } List<Map<String, String>> imports = new ArrayList<Map<String, String>>(); for (String s : importSet) { Map<String, String> item = new HashMap<String, String>(); item.put("import", s); imports.add(item); } objs.put("imports", imports); config.postProcessModels(objs); return objs; }