/** {@inheritDoc} */ protected void getNewMonitors(Map<String, Monitor> map) throws MonitorException { assert Thread.holdsLock(this); int used = prologue.getUsed(); long modificationTime = prologue.getModificationTimeStamp(); if ((used > lastUsed) || (lastModificationTime > modificationTime)) { lastUsed = used; lastModificationTime = modificationTime; Monitor monitor = getNextMonitorEntry(); while (monitor != null) { String name = monitor.getName(); // guard against duplicate entries if (!map.containsKey(name)) { map.put(name, monitor); /* * insertedMonitors is null when called from pollFor() * via buildMonitorMap(). Since we update insertedMonitors * at the end of buildMonitorMap(), it's ok to skip the * add here. */ if (insertedMonitors != null) { insertedMonitors.add(monitor); } } monitor = getNextMonitorEntry(); } } }
PCNode insertFullName(String full_name, boolean cl, boolean weavable) { int dotpos = full_name.indexOf('.'); String head; String rest; if (dotpos == -1) { head = full_name; rest = null; } else { head = full_name.substring(0, dotpos); rest = full_name.substring(dotpos + 1); } PCNode child; if (!inners.containsKey(head)) { child = new PCNode(head, this, root); inners.put(head, child); } else { child = (PCNode) inners.get(head); } if (rest != null) { return child.insertFullName(rest, cl, weavable); } else { child.is_class |= cl; child.is_weavable |= weavable; return child; } }
// Store the invariant for later printing. Ignore duplicate // invariants at the same program point. private static boolean store_invariant( String predicate, String index, HashedConsequent consequent, String pptname) { if (!pptname_to_conditions.containsKey(pptname)) { pptname_to_conditions.put(pptname, new HashMap<String, Map<String, HashedConsequent>>()); } Map<String, Map<String, HashedConsequent>> cluster_to_conditions = pptname_to_conditions.get(pptname); if (!cluster_to_conditions.containsKey(predicate)) { cluster_to_conditions.put(predicate, new HashMap<String, HashedConsequent>()); } Map<String, HashedConsequent> conditions = cluster_to_conditions.get(predicate); if (conditions.containsKey(index)) { HashedConsequent old = conditions.get(index); if (old.fakeFor != null && consequent.fakeFor == null) { // We already saw (say) "x != y", but we're "x == y", so replace it. conditions.remove(index); conditions.remove(old.fakeFor); conditions.put(index, consequent); return true; } return false; } else { conditions.put(index, consequent); return true; } }
@Override public Node execute(ExecutionContext ec, Template tmpl) throws IOException { // {{{ Map<String, StartNamedBlock> blocks = tmpl.getBlocks(); Node n = blocks.get(this.blockName); if (blocks.containsKey(this.blockName)) { return blocks.get(this.blockName).getExecuteNode(); } else { return this.executeNode; } // return this.getNextNode(); } // }}}
private void mergeDiseaseFreeData( Map<String, DiseaseFreeData> sourceMap, Map<String, DiseaseFreeData> destMap) { for (String patientId : sourceMap.keySet()) { DiseaseFreeData diseaseFreeData = sourceMap.get(patientId); if (destMap.containsKey(patientId)) { destMap.put(patientId, mergeDiseaseFreeData(destMap.get(patientId), diseaseFreeData)); } else { destMap.put(patientId, diseaseFreeData); } } }
private void mergeSurvivalData( Map<String, SurvivalData> sourceMap, Map<String, SurvivalData> destMap) { for (String patientId : sourceMap.keySet()) { SurvivalData survivalData = sourceMap.get(patientId); if (destMap.containsKey(patientId)) { destMap.put(patientId, mergeSurvivalData(destMap.get(patientId), survivalData)); } else { destMap.put(patientId, survivalData); } } }
/** * The convert method translates a String input to a specified outbound level of the same coding * scheme. For example, the input string value may be a tag-encoding URI and the outbound level * specified by string outboundlevel may be BINARY, in which case the return value is a binary * representation expressed as a string. * * @param input the identifier to be converted. * @param inputParameters additional parameters which need to be provided because they cannot * always be determined from the input value alone. Examples include the taglength, * companyprefixlength and filter values. * @param outputLevel the outbound level required for the ouput. Permitted values include BINARY, * TAG_ENCODING, PURE_IDENTITY, LEGACY and ONS_HOSTNAME. * @return the identifier converted to the output level. */ public String convert( String input, Map<String, String> inputParameters, LevelTypeList outputLevel) { TagLengthList tagLength = null; if (inputParameters.containsKey("taglength")) { // in principle, the user should provide a // TagLengthList object in the parameter list. String s = inputParameters.get("taglength"); tagLength = TagLengthList.valueOf(s); } PrefixMatch match = findPrefixMatch(input, tagLength); return convertLevel(match.getScheme(), match.getLevel(), input, inputParameters, outputLevel); }
private Map<String, DiseaseFreeData> getDiseaseFreeDataForMatrix(DataMatrix dataMatrix) { Map<String, DiseaseFreeData> diseaseFreeDataMap = new HashMap<String, DiseaseFreeData>(); List<String> patientIds = getPatientIds(dataMatrix); for (int lc = 0; lc < patientIds.size(); lc++) { String patientId = patientIds.get(lc); DiseaseFreeData df = getDiseaseFreeDataForPatient(lc, dataMatrix); if (diseaseFreeDataMap.containsKey(patientId)) { df = mergeDiseaseFreeData(diseaseFreeDataMap.get(patientId), df); } diseaseFreeDataMap.put(patientId, df); } return diseaseFreeDataMap; }
private Map<String, SurvivalData> getSurvivalDataForMatrix(DataMatrix dataMatrix) { Map<String, SurvivalData> survivalDataMap = new HashMap<String, SurvivalData>(); List<String> patientIds = getPatientIds(dataMatrix); for (int lc = 0; lc < patientIds.size(); lc++) { String patientId = patientIds.get(lc); SurvivalData sd = getSurvivalDataForPatient(lc, dataMatrix); if (survivalDataMap.containsKey(patientId)) { sd = mergeSurvivalData(survivalDataMap.get(patientId), sd); } survivalDataMap.put(patientId, sd); } return survivalDataMap; }
/** * Returns the value of a specified fieldname from the specified hashmap and returns an integer * value or throws an exception if the value is not an integer */ private int getIntValue(String fieldname, Map<String, String> extraparams) { Matcher checkint = Pattern.compile("^\\d+$").matcher(fieldname); int rv; if (checkint.matches()) { rv = Integer.parseInt(fieldname); } else { if (extraparams.containsKey(fieldname)) { rv = Integer.parseInt(extraparams.get(fieldname)); } else { rv = -1; throw new TDTException( "No integer value for " + fieldname + " can be found - check extraparams"); } } return rv; }
static int lonelyInteger(int[] arr) { Map<Integer, Integer> occurrences = new HashMap<>(); for (int value : arr) { boolean alreadyExist = occurrences.containsKey(value); if (!alreadyExist) { occurrences.put(value, 0); } occurrences.put(value, occurrences.get(value) + 1); } int result = 0; for (java.util.Map.Entry<Integer, Integer> entry : occurrences.entrySet()) { if (entry.getValue().equals(1)) { result = entry.getKey(); } } return result; }