public void testHeadNotPopular() throws Exception { VersionCounts versionCounts = VersionCounts.make(); VoteBlock vb1 = makeVoteBlock("http://test.com/foo1"); byte[] hash1 = addVersion(vb1, "content 1 for foo1"); byte[] hash2 = addVersion(vb1, "content 2 for foo1"); VoteBlock vb2 = makeVoteBlock("http://test.com/foo1"); addVersion(vb2, "content 1 for foo1"); addVersion(vb2, "content 2 for foo1"); VoteBlock vb3 = makeVoteBlock("http://test.com/foo1"); addVersion(vb3, "content 3 for foo1"); addVersion(vb3, "content 2 for foo1"); versionCounts.vote(vb1, participant1); versionCounts.vote(vb2, participant2); versionCounts.vote(vb3, participant3); Map<ParticipantUserData, HashResult> repairCandidates; repairCandidates = versionCounts.getRepairCandidates(0); assertSameElements( SetUtil.set(participant1, participant2, participant3), repairCandidates.keySet()); repairCandidates = versionCounts.getRepairCandidates(1); assertSameElements( SetUtil.set(participant1, participant2, participant3), repairCandidates.keySet()); repairCandidates = versionCounts.getRepairCandidates(2); assertSameElements(SetUtil.set(participant1, participant2), repairCandidates.keySet()); repairCandidates = versionCounts.getRepairCandidates(3); assertEmpty(repairCandidates.keySet()); }
public String buildInterfaceTable(String rule, String[] serviceList) throws FilterParseException { StringBuffer buffer = new StringBuffer(); Filter filter = new Filter(); Map interfaces = filter.getIPServiceMap(rule); Iterator i = interfaces.keySet().iterator(); while (i.hasNext()) { String key = (String) i.next(); buffer.append("<tr><td valign=\"top\">").append(key).append("</td>"); buffer.append("<td>"); if (serviceList != null && serviceList.length != 0) { Map services = (Map) interfaces.get(key); Iterator j = services.keySet().iterator(); while (j.hasNext()) { String svc = (String) j.next(); for (int idx = 0; idx < serviceList.length; idx++) { if (svc.equals(serviceList[idx])) { buffer.append(svc).append("<br>"); } } } } else { buffer.append("All services"); } buffer.append("</td>"); buffer.append("</tr>"); } return buffer.toString(); }
// 默认顺序createtime desc public List<T> findByMapWithCond(Map<String, Object> params, String orderBy, Boolean asc) { StringBuilder hql = new StringBuilder("from " + className); String orderStr; if (null == orderBy) { orderStr = " order by createtime desc"; } else { String ascStr = asc ? " asc" : " desc"; orderStr = " order by " + orderBy + ascStr; } Map<String, Object> alterParams = new HashMap<>(); Query query; if (null != params && !params.isEmpty()) { hql.append(" where "); for (String field : params.keySet()) { int i = field.indexOf(" "); Assert.isTrue(i != -1, "Wrong condition, must have space inside!"); String ramdonName = "_" + Utils.getRandomString(8); hql.append(field).append(" :").append(ramdonName).append(" and "); if (field.contains("like")) { String likeStr = "%" + params.get(field) + "%"; alterParams.put(ramdonName, likeStr); } else alterParams.put(ramdonName, params.get(field)); } hql.append("1=1"); query = getSession().createQuery(hql.append(orderStr).toString()); for (String field : alterParams.keySet()) query.setParameter(field, alterParams.get(field)); } else query = getSession().createQuery(hql.append(orderStr).toString()); return query.list(); }
@Test public void testPutRemoveGet() { Map<Integer, Integer> myMap = new MyMap<>(); Map<Integer, Integer> control = new HashMap<>(); for (int i = 0; i < N; i++) { int k = random.nextInt(); int v = random.nextInt(); myMap.put(k, v); control.put(k, v); } Set<Integer> keysToRemove = new HashSet<>(); for (int k : control.keySet()) { if (random.nextBoolean()) { keysToRemove.add(k); } } for (int k : keysToRemove) { control.remove(k); myMap.remove(k); } assertEquals(myMap.size(), control.size()); for (int k : control.keySet()) { assertEquals(myMap.get(k), control.get(k)); int r = random.nextInt(); assertEquals(myMap.get(r), control.get(r)); } }
protected void compareJSONArrayOfSimpleValues( String key, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException { Map<Object, Integer> expectedCount = JSONCompareUtil.getCardinalityMap(jsonArrayToList(expected)); Map<Object, Integer> actualCount = JSONCompareUtil.getCardinalityMap(jsonArrayToList(actual)); for (Object o : expectedCount.keySet()) { if (!actualCount.containsKey(o)) { result.missing(key + "[]", o); } else if (!actualCount.get(o).equals(expectedCount.get(o))) { result.fail( key + "[]: Expected " + expectedCount.get(o) + " occurrence(s) of " + o + " but got " + actualCount.get(o) + " occurrence(s)"); } } for (Object o : actualCount.keySet()) { if (!expectedCount.containsKey(o)) { result.unexpected(key + "[]", o); } } }
// --------------------------------------------------------------------------- private void printDependencies() throws TablesawException { m_printedDependencies = new HashSet<String>(); try { PrintWriter pw = new PrintWriter(new FileWriter("dependency.txt")); pw.println("Targets marked with a * have already been printed"); // Create a reduced set of stuff to print Set<String> ruleNames = new HashSet<String>(); for (String name : m_nameRuleMap.keySet()) ruleNames.add(name); for (String name : m_nameRuleMap.keySet()) { Rule rule = m_nameRuleMap.get(name); for (String dep : rule.getDependNames()) ruleNames.remove(dep); for (Rule dep : rule.getDependRules()) { if (dep.getName() != null) ruleNames.remove(dep.getName()); } } for (String name : ruleNames) { if (!name.startsWith(NAMED_RULE_PREFIX)) printDependencies(name, pw, 0); } pw.close(); } catch (IOException ioe) { throw new TablesawException("Cannot write to file dependency.txt", -1); } }
// Walks the tree, checking to make sure that we haven't violated any // logical constraints. This is a method for debugging. public boolean check() { String path = pathLabel(); if (suffixLink != null) { String suffixPath = suffixLink.pathLabel(); if (!path.substring(1, path.length()).equals(suffixPath)) { logger.log( Level.SEVERE, String.format("Suffix Link for node (%s) didn't match: %s", path, suffixPath)); return false; } } for (char c : childEdges.keySet()) { TreeEdge e = childEdges.get(c); if (!e.check()) { return false; } } for (int k : terminalEdges.keySet()) { TreeEdge e = terminalEdges.get(k); if (!e.check()) { return false; } } return true; }
@Override public Response serve(IHTTPSession session) { Map<String, String> header = session.getHeaders(); Map<String, String> parms = session.getParms(); String uri = session.getUri(); if (logRequests) { Log.i(TAG, session.getMethod() + " '" + uri + "' "); Iterator<String> e = header.keySet().iterator(); while (e.hasNext()) { String value = e.next(); Log.i(TAG, " HDR: '" + value + "' = '" + header.get(value) + "'"); } e = parms.keySet().iterator(); while (e.hasNext()) { String value = e.next(); Log.i(TAG, " PRM: '" + value + "' = '" + parms.get(value) + "'"); } } if (!webRoot.isDirectory()) { return createResponse( Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "INTERNAL ERRROR: given path is not a directory (" + webRoot + ")."); } return respond(Collections.unmodifiableMap(header), uri); }
protected void compareJSONArrayOfJsonObjects( String key, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException { String uniqueKey = findUniqueKey(expected); if (uniqueKey == null || !isUsableAsUniqueKey(uniqueKey, actual)) { // An expensive last resort recursivelyCompareJSONArray(key, expected, actual, result); return; } Map<Object, JSONObject> expectedValueMap = arrayOfJsonObjectToMap(expected, uniqueKey); Map<Object, JSONObject> actualValueMap = arrayOfJsonObjectToMap(actual, uniqueKey); for (Object id : expectedValueMap.keySet()) { if (!actualValueMap.containsKey(id)) { result.missing(formatUniqueKey(key, uniqueKey, id), expectedValueMap.get(id)); continue; } JSONObject expectedValue = expectedValueMap.get(id); JSONObject actualValue = actualValueMap.get(id); compareValues(formatUniqueKey(key, uniqueKey, id), expectedValue, actualValue, result); } for (Object id : actualValueMap.keySet()) { if (!expectedValueMap.containsKey(id)) { result.unexpected(formatUniqueKey(key, uniqueKey, id), actualValueMap.get(id)); } } }
/** Test that the iterator order matches the keySet order. */ public void testMapIteratorOrder() { if (supportsFullIterator() == false) { return; } OrderedMapIterator it = makeFullOrderedMapIterator(); Map map = getMap(); assertEquals( "keySet() not consistent", new ArrayList(map.keySet()), new ArrayList(map.keySet())); Iterator it2 = map.keySet().iterator(); assertEquals(true, it.hasNext()); assertEquals(true, it2.hasNext()); List list = new ArrayList(); while (it.hasNext()) { Object key = it.next(); assertEquals(it2.next(), key); list.add(key); } assertEquals(map.size(), list.size()); while (it.hasPrevious()) { Object key = it.previous(); assertEquals(list.get(list.size() - 1), key); list.remove(list.size() - 1); } assertEquals(0, list.size()); }
@Test public void testPaging() throws ClientException { Session session = getSession(); try { Map<String, Serializable> filter = new HashMap<String, Serializable>(); filter.put("label", "Label"); Map<String, String> order = new HashMap<String, String>(); order.put("id", "ASC"); List<DocumentModel> entries = session.query(filter, filter.keySet()); assertEquals(12, entries.size()); assertEquals("1", entries.get(0).getId()); entries = session.query(filter, filter.keySet(), order, false, 5, -1); assertEquals(5, entries.size()); assertEquals("1", entries.get(0).getId()); entries = session.query(filter, filter.keySet(), order, false, 5, 1); assertEquals(5, entries.size()); assertEquals("2", entries.get(0).getId()); entries = session.query(filter, filter.keySet(), order, false, 5, 11); assertEquals(1, entries.size()); assertEquals("12", entries.get(0).getId()); } catch (UnsupportedOperationException e) { // Swallow it } finally { session.close(); } }
public void testMultipleIdenticalVersions() throws Exception { VersionCounts versionCounts = VersionCounts.make(); VoteBlock vb1 = makeVoteBlock("http://test.com/foo1"); byte[] hash1 = addVersion(vb1, "content 1 for foo1"); byte[] hash2 = addVersion(vb1, "content 2 for foo1"); VoteBlock vb2 = makeVoteBlock("http://test.com/foo1"); addVersion(vb2, "content 1 for foo1"); addVersion(vb2, "content 1 for foo1"); addVersion(vb2, "content 1 for foo1"); addVersion(vb2, "content 1 for foo1"); addVersion(vb2, "content 2 for foo1"); VoteBlock vb3 = makeVoteBlock("http://test.com/foo1"); addVersion(vb3, "content 1 for foo1"); addVersion(vb3, "content 2 for foo1"); addVersion(vb3, "content 2 for foo1"); addVersion(vb3, "content 2 for foo1"); addVersion(vb3, "content 2 for foo1"); versionCounts.vote(vb1, participant1); versionCounts.vote(vb2, participant2); versionCounts.vote(vb3, participant3); Map<ParticipantUserData, HashResult> repairCandidates; repairCandidates = versionCounts.getRepairCandidates(2); assertSameElements( SetUtil.set(participant1, participant2, participant3), repairCandidates.keySet()); // With only three candidates, no version should reach a threshold // of 4, unless counting multiples is wrong. repairCandidates = versionCounts.getRepairCandidates(4); assertEmpty(repairCandidates.keySet()); }
@NotNull private List<String> createCurrentSeverityNames() { List<String> list = new ArrayList<String>(); list.addAll(STANDARD_SEVERITIES.keySet()); list.addAll(myMap.keySet()); ContainerUtil.sort(list); return list; }
public Collection<EvaluationRecordGroup> getEvaluationGroups() { for (EvaluationRecordGroup evaluationRecordGroup : groupClusterCenter.keySet()) { for (EvaluationRecord evaluationRecord : evaluationRecordGroup.getRecords()) { evaluationRecord.addValue(evaluationRecordGroup.getName()); } } return groupClusterCenter.keySet(); }
public void collectSuffixes(Set<StringSuffix> suffices) { suffices.addAll(suffixes); for (char key : childEdges.keySet()) { childEdges.get(key).tailNode.collectSuffixes(suffices); } for (int key : terminalEdges.keySet()) { terminalEdges.get(key).tailNode.collectSuffixes(suffices); } }
/** Get an alphabetically sorted list of field names. */ public List<String> getFieldNames() { HashSet<String> names = new HashSet<String>(); names.addAll(storedFields.keySet()); names.addAll(reconstructedFields.keySet()); ArrayList<String> res = new ArrayList<String>(names.size()); res.addAll(names); Collections.sort(res); return res; }
public void add(Date date, double open, double close) { if (posValues.keySet().size() != 1) { return; } Position pos = (Position) posValues.keySet().iterator().next(); TimePeriodValuesCollection values = getCollection(pos); TimePeriod time = new SimpleTimePeriod(date, date); values.getSeries(PriceHistoryRecord.OPEN).add(time, open); values.getSeries(PriceHistoryRecord.CLOSE).add(time, close); }
@NotNull Set<VirtualFile> getAllRoots() { LinkedHashSet<VirtualFile> result = ContainerUtil.newLinkedHashSet(); result.addAll(classAndSourceRoots); result.addAll(contentRootOf.keySet()); result.addAll(excludedFromLibraries.keySet()); result.addAll(excludedFromModule.keySet()); result.addAll(excludedFromProject); return result; }
public XBarGrammarProjection(BinaryGrammar bg, UnaryGrammar ug) { Map<BinaryRule, BinaryRule> binaryRules = new HashMap<BinaryRule, BinaryRule>(); Map<UnaryRule, UnaryRule> unaryRules = new HashMap<UnaryRule, UnaryRule>(); sourceUG = ug; sourceBG = bg; sourceNumberer = Numberer.getGlobalNumberer(bg.stateSpace()); targetNumberer = Numberer.getGlobalNumberer(bg.stateSpace() + "-xbar"); projection = new int[sourceNumberer.total()]; scanStates(sourceNumberer, targetNumberer); targetBG = new BinaryGrammar(targetNumberer.total(), bg.stateSpace() + "-xbar"); targetUG = new UnaryGrammar(targetNumberer.total()); for (Iterator<BinaryRule> brI = bg.iterator(); brI.hasNext(); ) { BinaryRule rule = projectBinaryRule(brI.next()); Rule old = binaryRules.get(rule); if (old == null || rule.score > old.score) { binaryRules.put(rule, rule); } } for (BinaryRule br : binaryRules.keySet()) { targetBG.addRule(br); // System.out.println("BR: "+targetNumberer.object(br.parent)+" -> // "+targetNumberer.object(br.leftChild)+" "+targetNumberer.object(br.rightChild)+" %% // "+br.score); } targetBG.splitRules(); for (int parent = 0; parent < sourceNumberer.total(); parent++) { for (Iterator<UnaryRule> urI = ug.ruleIteratorByParent(parent); urI.hasNext(); ) { UnaryRule sourceRule = urI.next(); UnaryRule rule = projectUnaryRule(sourceRule); Rule old = unaryRules.get(rule); if (old == null || rule.score > old.score) { unaryRules.put(rule, rule); } /* if (((UnaryRule)rule).child == targetNumberer.number("PRP") && ((String)sourceNumberer.object(rule.parent)).charAt(0) == 'N') { System.out.println("Source UR: "+sourceRule+" %% "+sourceRule.score); System.out.println("Score of "+rule+"is now: "+((UnaryRule)unaryRules.get(rule)).score); } */ } } for (UnaryRule ur : unaryRules.keySet()) { targetUG.addRule(ur); // System.out.println("UR: "+targetNumberer.object(ur.parent)+" -> // "+targetNumberer.object(ur.child)+" %% "+ur.score); } targetUG.purgeRules(); System.out.println( "Projected " + sourceNumberer.total() + " states to " + targetNumberer.total() + " states."); }
public void initialize() { Debug.log(2, "SikuliEventManager: resetting observe states for " + _region.toStringShort()); sthgLeft = true; for (Object ptn : _state.keySet()) { _state.put(ptn, State.FIRST); _count.put(ptn, 0); } for (int n : _changeOb.keySet()) { _countc.put(n, 0); } }
public String toString() { StringBuilder sb = new StringBuilder(); sb.append("Raw lexicon:\n\n"); for (String s : captionToRawQuery.keySet()) sb.append(s + ":" + captionToRawQuery.get(s) + "\n"); sb.append( "\n-----------------------------------------------------------------------------\n"); sb.append("Expanded lexicon:\n\n"); for (String s : captionToExpandedQuery.keySet()) sb.append(s + ":" + captionToExpandedQuery.get(s) + "\n"); return sb.toString(); }
public ExitCode build( final CompileContext context, final ModuleChunk chunk, DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder, OutputConsumer outputConsumer) throws ProjectBuildException { if (!IS_ENABLED.get(context, Boolean.TRUE)) { return ExitCode.NOTHING_DONE; } try { final Map<File, ModuleBuildTarget> filesToCompile = new THashMap<File, ModuleBuildTarget>(FileUtil.FILE_HASHING_STRATEGY); dirtyFilesHolder.processDirtyFiles( new FileProcessor<JavaSourceRootDescriptor, ModuleBuildTarget>() { public boolean apply( ModuleBuildTarget target, File file, JavaSourceRootDescriptor descriptor) throws IOException { if (JAVA_SOURCES_FILTER.accept(file)) { filesToCompile.put(file, target); } return true; } }); if (context.isMake()) { final ProjectBuilderLogger logger = context.getLoggingManager().getProjectBuilderLogger(); if (logger.isEnabled()) { if (filesToCompile.size() > 0) { logger.logCompiledFiles(filesToCompile.keySet(), BUILDER_NAME, "Compiling files:"); } } } return compile(context, chunk, dirtyFilesHolder, filesToCompile.keySet(), outputConsumer); } catch (ProjectBuildException e) { throw e; } catch (Exception e) { String message = e.getMessage(); if (message == null) { final ByteArrayOutputStream out = new ByteArrayOutputStream(); final PrintStream stream = new PrintStream(out); try { e.printStackTrace(stream); } finally { stream.close(); } message = "Internal error: \n" + out.toString(); } context.processMessage(new CompilerMessage(BUILDER_NAME, BuildMessage.Kind.ERROR, message)); throw new ProjectBuildException(message, e); } }
@Action( value = "/admin/exitTerms", results = {@Result(name = "success", location = "/admin/menu.action", type = "redirect")}) public String exitTerms() { Long userId = AuthUtil.getUserId(servletRequest.getSession()); // check user map if (userSchSessionMap != null && !userSchSessionMap.isEmpty()) { // get user servletRequest.getSession()s for (Long userKey : userSchSessionMap.keySet()) { UserSchSessions userSchSessions = userSchSessionMap.get(userKey); // get current time and subtract number of hours set to determine expire time Calendar expireTime = Calendar.getInstance(); expireTime.add( Calendar.HOUR, (-1 * Integer.parseInt( AppConfigLkup.getProperty( "timeoutSshAfter")))); // subtract hours to get expire time // if current user or session has timed out remove ssh session if (userId.equals(userKey) || userSchSessions.getStartTime().before(expireTime.getTime())) { Map<Long, SchSession> schSessionMap = userSchSessionMap.get(userKey).getSchSessionMap(); for (Long sessionKey : schSessionMap.keySet()) { SchSession schSession = schSessionMap.get(sessionKey); // disconnect ssh session schSession.getChannel().disconnect(); schSession.getSession().disconnect(); schSession.setChannel(null); schSession.setSession(null); schSession.setInputToChannel(null); schSession.setCommander(null); schSession.setOutFromChannel(null); schSession = null; // remove from map schSessionMap.remove(sessionKey); } // clear and remove session map for user schSessionMap.clear(); userSchSessionMap.remove(userKey); SessionOutputUtil.removeUserSession(userKey); } } } return SUCCESS; }
public static Graph getCompleteClique(boolean directed) { Graph graph = new Graph("HGNC complete clique", "clique-edge"); for (String s1 : sym2id.keySet()) { for (String s2 : sym2id.keySet()) { if (s1.equals(s2)) continue; if (!directed && s2.compareTo(s1) < 0) continue; graph.putRelation(s1, s2, directed); graph.putRelation(s1, s2, directed); } } return graph; }
public void findStudentResult(String name) { System.out.println("Student name:" + name); Map<Subject, Double> subjectDoubleMap = new HashMap<>(); Map<Subject, Integer> subjectIntegerMap = new HashMap<>(); /** * бежим по группам с типом результатов double и ищем студента если есть, то записываем в * subjectDoubleMap */ for (Group<Double> indexDGroup : dGroups) { if (indexDGroup.getEvalByName(name) == null) { continue; } else { subjectDoubleMap.put(indexDGroup.getSubject(), indexDGroup.getEvalByName(name)); } } /* * результируюзщий map не пустой, то выводим на экран * */ if (!subjectDoubleMap.isEmpty()) { System.out.println(subjectDoubleMap); double max1 = Collections.max(subjectDoubleMap.values()); for (Subject s : subjectDoubleMap.keySet()) { if (subjectDoubleMap.get(s) == max1) { System.out.println(s + ":" + max1); } } } /** * бежим по группам с типом результатов integer и ищем студента если есть, то записываем в * subjectDoubleMap */ for (Group<Integer> indexIGroup : iGroups) { if (indexIGroup.getEvalByName(name) == null) { continue; } else { subjectIntegerMap.put(indexIGroup.getSubject(), indexIGroup.getEvalByName(name)); } } if (!subjectIntegerMap.isEmpty()) { System.out.println(subjectIntegerMap); int max2 = Collections.max(subjectIntegerMap.values()); for (Subject s : subjectIntegerMap.keySet()) { if (subjectIntegerMap.get(s) == max2) { System.out.println(s + ":" + max2); } } } }
public String execute(Map<String, String> map) throws TwilioRestException { List<NameValuePair> params = new ArrayList<NameValuePair>(map.keySet().size()); Set<String> keys = map.keySet(); for (String key : keys) { params.add(new BasicNameValuePair(key, map.get(key))); } MessageFactory messageFactory = getAccount().getMessageFactory(); Message message = messageFactory.create(params); return message.getSid(); }
/* * Validate if all imports for a feature are being matched with exports */ private void validateImportsExports(Feature feature) throws Exception { Map<Clause, String> imports = new HashMap<Clause, String>(); Set<Clause> exports = new HashSet<Clause>(); for (Dependency dependency : feature.getDependencies()) { if (featureExports.containsKey(dependency.getName())) { exports.addAll(featureExports.get(dependency.getName())); } else { validateImportsExports(features.get(dependency.getName(), dependency.getVersion())); } } for (String bundle : getBundleLocations(feature)) { Manifest meta = manifests.get(bundles.get(bundle)); exports.addAll(getExports(meta)); for (Clause clause : getMandatoryImports(meta)) { imports.put(clause, bundle); } } // setting up the set of required imports Set<Clause> requirements = new HashSet<Clause>(); requirements.addAll(imports.keySet()); // now, let's remove requirements whenever we find a matching export for them for (Clause element : imports.keySet()) { if (systemExports.contains(element.getName())) { debug("%s is resolved by a system bundle export or provided bundle", element); requirements.remove(element); continue; } for (Clause export : exports) { if (matches(element, export)) { debug("%s is resolved by export %s", element, export); requirements.remove(element); continue; } debug("%s is not resolved by export %s", element, export); } } // if there are any more requirements left here, there's a problem with the feature if (!requirements.isEmpty()) { warn("Failed to validate feature %s", feature.getName()); for (Clause entry : requirements) { warn("No export found to match %s (imported by %s)", entry, imports.get(entry)); } throw new Exception( String.format( "%d unresolved imports in feature %s", requirements.size(), feature.getName())); } info(" OK: imports resolved for %s", feature.getName()); featureExports.put(feature.getName(), exports); }
@Override public void writeExternal(Element element) throws WriteExternalException { final CodeStyleSettings parentSettings = new CodeStyleSettings(); DefaultJDOMExternalizer.writeExternal( this, element, new DifferenceFilter<CodeStyleSettings>(this, parentSettings)); List<CustomCodeStyleSettings> customSettings = new ArrayList<CustomCodeStyleSettings>(getCustomSettingsValues()); Collections.sort( customSettings, new Comparator<CustomCodeStyleSettings>() { @Override public int compare(final CustomCodeStyleSettings o1, final CustomCodeStyleSettings o2) { return o1.getTagName().compareTo(o2.getTagName()); } }); for (final CustomCodeStyleSettings settings : customSettings) { final CustomCodeStyleSettings parentCustomSettings = parentSettings.getCustomSettings(settings.getClass()); if (parentCustomSettings == null) { throw new WriteExternalException("Custom settings are null for " + settings.getClass()); } settings.writeExternal(element, parentCustomSettings); } final FileType[] fileTypes = myAdditionalIndentOptions .keySet() .toArray(new FileType[myAdditionalIndentOptions.keySet().size()]); Arrays.sort( fileTypes, new Comparator<FileType>() { @Override public int compare(final FileType o1, final FileType o2) { return o1.getDefaultExtension().compareTo(o2.getDefaultExtension()); } }); for (FileType fileType : fileTypes) { final IndentOptions indentOptions = myAdditionalIndentOptions.get(fileType); Element additionalIndentOptions = new Element(ADDITIONAL_INDENT_OPTIONS); indentOptions.serialize(additionalIndentOptions, getDefaultIndentOptions(fileType)); additionalIndentOptions.setAttribute(FILETYPE, fileType.getDefaultExtension()); if (!additionalIndentOptions.getChildren().isEmpty()) { element.addContent(additionalIndentOptions); } } myCommonSettingsManager.writeExternal(element); }
public static List<Configurable> buildConfigurablesList( final ConfigurableEP<Configurable>[] extensions, final Configurable[] components, @Nullable ConfigurableFilter filter) { final List<Configurable> result = new ArrayList<Configurable>(); for (Configurable component : components) { if (!isSuppressed(component, filter)) { result.add(component); } } final Map<String, ConfigurableWrapper> idToConfigurable = new HashMap<String, ConfigurableWrapper>(); for (ConfigurableEP<Configurable> ep : extensions) { final Configurable configurable = ConfigurableWrapper.wrapConfigurable(ep); if (isSuppressed(configurable, filter)) continue; if (configurable instanceof ConfigurableWrapper) { final ConfigurableWrapper wrapper = (ConfigurableWrapper) configurable; idToConfigurable.put(wrapper.getId(), wrapper); } else { // dumpConfigurable(configurablesExtensionPoint, ep, configurable); ContainerUtil.addIfNotNull(configurable, result); } } // modify configurables (append children) for (final String id : idToConfigurable.keySet()) { final ConfigurableWrapper wrapper = idToConfigurable.get(id); final String parentId = wrapper.getParentId(); if (parentId != null) { final ConfigurableWrapper parent = idToConfigurable.get(parentId); if (parent != null) { idToConfigurable.put(parentId, parent.addChild(wrapper)); } else { LOG.debug("Can't find parent for " + parentId + " (" + wrapper + ")"); } } } // leave only roots (i.e. configurables without parents) for (final Iterator<String> iterator = idToConfigurable.keySet().iterator(); iterator.hasNext(); ) { final String key = iterator.next(); final ConfigurableWrapper wrapper = idToConfigurable.get(key); final String parentId = wrapper.getParentId(); if (parentId != null && idToConfigurable.containsKey(parentId)) { iterator.remove(); // remove only processed parents } } ContainerUtil.addAll(result, idToConfigurable.values()); return result; }
protected String makeKeys() { StringBuffer sb = new StringBuffer(); for (Iterator it = props.keySet().iterator(); it.hasNext(); ) { if (sb.length() > 0) { sb.append(','); } sb.append(it.next().toString()); } for (Iterator it = props_default.keySet().iterator(); it.hasNext(); ) { sb.append(','); sb.append(it.next().toString()); } return sb.toString(); }