private int maxTagLength() { int tl = 0; for (String tag : gappedAlignments.keySet()) { tl = Math.max(tl, tag.length()); } return tl; }
private void putMap(String name, Map m) { _put(OBJECT, name); final int sizePos = _buf.position(); _buf.putInt(0); for (Object key : m.keySet()) _putObjectField(key.toString(), m.get(key)); _buf.put(EOO); _buf.putInt(sizePos, _buf.position() - sizePos); }
static boolean isComposite(String name, Map<String, String[]> params) { for (String pName : params.keySet()) { if (pName.startsWith(name + ".") && params.get(pName) != null && params.get(pName).length > 0) { return true; } } return false; }
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); } } }
public Set /*<PCNode>*/ matchSpecific(Pattern simple_name_pattern) { Set matches = new HashSet(); Iterator ii = inners.keySet().iterator(); while (ii.hasNext()) { String inner = (String) ii.next(); // System.out.print("Matching "+inner+" against "+simple_name_pattern.pattern()+": "); if (simple_name_pattern.matcher(inner).matches()) { // System.out.println("true"); matches.add(inners.get(inner)); } else { // System.out.println("false"); } } return matches; }
/** * returns the multiple alignment as a string in a fashion identical to that in a file of * ALN/CLUSTALW format (except from the fact that info about residues' match is missing. Aka, the * 3rd line of a file of ALN/CLUSTALW ('*', '.', ':' chars) is missing). * * <p>(Note: CLUSTALW doesn't necessarily have the match characters... -Tim) */ public String toString() { StringBuilder sb = new StringBuilder(); int tl = maxTagLength(); int i = 0, last = gappedAlignments.keySet().size() - 1; for (String tag : gappedAlignments.keySet()) { sb.append(StringUtils.padString(tag, tl)); sb.append(" "); sb.append(gappedAlignments.get(tag).gappedString()); if (i < last) { sb.append("\n"); } i += 1; } return sb.toString(); }
/** Method to dump debugging information */ private void dumpAll(Map map, int lvmid) { if (DEBUG) { Set keys = map.keySet(); System.err.println("Dump for " + lvmid); int j = 0; for (Iterator i = keys.iterator(); i.hasNext(); j++) { Monitor monitor = (Monitor) map.get(i.next()); System.err.println(j + "\t" + monitor.getName() + "=" + monitor.getValue()); } System.err.println("nextEntry = " + nextEntry + " pollForEntry = " + pollForEntry); System.err.println("Buffer info:"); System.err.println("buffer = " + buffer); } }
private List<String> computeOverallSurvivalStatus(Map<String, SurvivalData> survivalData) { List<String> osStatus = initializeList(canonicalPatientList.size()); for (String patientId : survivalData.keySet()) { int osStatusIndex = canonicalPatientList.indexOf(patientId); SurvivalData sd = survivalData.get(patientId); if (VitalStatusAlive.has(sd.vitalStatus)) { osStatus.set(osStatusIndex, VitalStatusAlive.LIVING.toString()); } else if (VitalStatusDead.has(sd.vitalStatus)) { osStatus.set(osStatusIndex, VitalStatusDead.DECEASED.toString()); } else { osStatus.set(osStatusIndex, ClinicalAttribute.NA); } } return osStatus; }
private List<String> computeOverallSurvivalMonths(Map<String, SurvivalData> survivalData) { List<String> osStatusMonths = initializeList(canonicalPatientList.size()); for (String patientId : survivalData.keySet()) { int osStatusMonthsIndex = canonicalPatientList.indexOf(patientId); SurvivalData sd = survivalData.get(patientId); if (VitalStatusAlive.has(sd.vitalStatus)) { osStatusMonths.set( osStatusMonthsIndex, convertDaysToMonths(sd.lastFollowUp, sd.lastKnownAlive)); } else if (VitalStatusDead.has(sd.vitalStatus)) { osStatusMonths.set(osStatusMonthsIndex, convertDaysToMonths(sd.daysToDeath)); } else { osStatusMonths.set(osStatusMonthsIndex, ClinicalAttribute.NA); } } return osStatusMonths; }
private List<String> computeDiseaseFreeStatus(Map<String, DiseaseFreeData> diseaseFreeData) { List<String> dfStatus = initializeList(canonicalPatientList.size()); for (String patientId : diseaseFreeData.keySet()) { int dfStatusIndex = canonicalPatientList.indexOf(patientId); DiseaseFreeData df = diseaseFreeData.get(patientId); if (patientIsDiseaseFree(df)) { dfStatus.set(dfStatusIndex, DiseaseFreeStatus.DISEASE_FREE.toString()); } else { try { Integer.parseInt(df.daysToNewTumorEventAfterInitialTreatment); dfStatus.set(dfStatusIndex, DiseaseFreeStatus.DISEASED.toString()); } catch (NumberFormatException e) { dfStatus.set(dfStatusIndex, ClinicalAttribute.NA); } } } return dfStatus; }
private List<String> computeDiseaseFreeMonths(Map<String, DiseaseFreeData> diseaseFreeData) { List<String> dfStatusMonths = initializeList(canonicalPatientList.size()); for (String patientId : diseaseFreeData.keySet()) { int dfStatusMonthsIndex = canonicalPatientList.indexOf(patientId); DiseaseFreeData df = diseaseFreeData.get(patientId); try { if (patientIsDiseaseFree(df)) { dfStatusMonths.set( dfStatusMonthsIndex, convertDaysToMonths(df.lastFollowUp, df.lastKnownAlive)); } else { int dfStatusDays = Integer.parseInt(df.daysToNewTumorEventAfterInitialTreatment); dfStatusMonths.set( dfStatusMonthsIndex, convertDaysToMonths(Integer.toString(dfStatusDays))); } } catch (NumberFormatException e) { dfStatusMonths.set(dfStatusMonthsIndex, ClinicalAttribute.NA); } } return dfStatusMonths; }
private void discoverAndRunProcs( Context context, Set<TypeElement> annotationsPresent, List<ClassSymbol> topLevelClasses, List<PackageSymbol> packageInfoFiles) { Map<String, TypeElement> unmatchedAnnotations = new HashMap<String, TypeElement>(annotationsPresent.size()); for (TypeElement a : annotationsPresent) { unmatchedAnnotations.put(a.getQualifiedName().toString(), a); } // Give "*" processors a chance to match if (unmatchedAnnotations.size() == 0) unmatchedAnnotations.put("", null); DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator(); // TODO: Create proper argument values; need past round // information to fill in this constructor. Note that the 1 // st round of processing could be the last round if there // were parse errors on the initial source files; however, we // are not doing processing in that case. Set<Element> rootElements = new LinkedHashSet<Element>(); rootElements.addAll(topLevelClasses); rootElements.addAll(packageInfoFiles); rootElements = Collections.unmodifiableSet(rootElements); RoundEnvironment renv = new JavacRoundEnvironment(false, false, rootElements, JavacProcessingEnvironment.this); while (unmatchedAnnotations.size() > 0 && psi.hasNext()) { ProcessorState ps = psi.next(); Set<String> matchedNames = new HashSet<String>(); Set<TypeElement> typeElements = new LinkedHashSet<TypeElement>(); for (Map.Entry<String, TypeElement> entry : unmatchedAnnotations.entrySet()) { String unmatchedAnnotationName = entry.getKey(); if (ps.annotationSupported(unmatchedAnnotationName)) { matchedNames.add(unmatchedAnnotationName); TypeElement te = entry.getValue(); if (te != null) typeElements.add(te); } } if (matchedNames.size() > 0 || ps.contributed) { boolean processingResult = callProcessor(ps.processor, typeElements, renv); ps.contributed = true; ps.removeSupportedOptions(unmatchedProcessorOptions); if (printProcessorInfo || verbose) { log.printNoteLines( "x.print.processor.info", ps.processor.getClass().getName(), matchedNames.toString(), processingResult); } if (processingResult) { unmatchedAnnotations.keySet().removeAll(matchedNames); } } } unmatchedAnnotations.remove(""); if (lint && unmatchedAnnotations.size() > 0) { // Remove annotations processed by javac unmatchedAnnotations.keySet().removeAll(platformAnnotations); if (unmatchedAnnotations.size() > 0) { log = Log.instance(context); log.warning("proc.annotations.without.processors", unmatchedAnnotations.keySet()); } } // Run contributing processors that haven't run yet psi.runContributingProcs(renv); // Debugging if (options.isSet("displayFilerState")) filer.displayState(); }
private Set<String> initUnmatchedProcessorOptions() { Set<String> unmatchedProcessorOptions = new HashSet<String>(); unmatchedProcessorOptions.addAll(processorOptions.keySet()); return unmatchedProcessorOptions; }
@SuppressWarnings("unchecked") static Object bindInternal( String name, Class clazz, Type type, Annotation[] annotations, Map<String, String[]> params, String suffix, String[] profiles) { try { Logger.trace("bindInternal: name [" + name + "] suffix [" + suffix + "]"); String[] value = params.get(name + suffix); Logger.trace("bindInternal: value [" + value + "]"); Logger.trace("bindInternal: profile [" + Utils.join(profiles, ",") + "]"); // Let see if we have a BindAs annotation and a separator. If so, we need to split the values // Look up for the BindAs annotation. Extract the profile if there is any. // TODO: Move me somewhere else? if (annotations != null) { for (Annotation annotation : annotations) { if ((clazz.isArray() || Collection.class.isAssignableFrom(clazz)) && value != null && value.length > 0 && annotation.annotationType().equals(As.class)) { As as = ((As) annotation); final String separator = as.value()[0]; value = value[0].split(separator); } if (annotation.annotationType().equals(NoBinding.class)) { NoBinding bind = ((NoBinding) annotation); String[] localUnbindProfiles = bind.value(); Logger.trace( "bindInternal: localUnbindProfiles [" + Utils.join(localUnbindProfiles, ",") + "]"); if (localUnbindProfiles != null && contains(profiles, localUnbindProfiles)) { return NO_BINDING; } } } } // Arrays types // The array condition is not so nice... We should find another way of doing this.... if (clazz.isArray() && (clazz != byte[].class && clazz != byte[][].class && clazz != File[].class && clazz != Upload[].class)) { if (value == null) { value = params.get(name + suffix + "[]"); } if (value == null) { return MISSING; } Object r = Array.newInstance(clazz.getComponentType(), value.length); for (int i = 0; i <= value.length; i++) { try { Array.set(r, i, directBind(name, annotations, value[i], clazz.getComponentType())); } catch (Exception e) { // ?? One item was bad } } return r; } // Enums if (Enum.class.isAssignableFrom(clazz)) { if (value == null || value.length == 0) { return MISSING; } else if (StringUtils.isEmpty(value[0])) { return null; } return Enum.valueOf(clazz, value[0]); } // Map if (Map.class.isAssignableFrom(clazz)) { Class keyClass = String.class; Class valueClass = String.class; if (type instanceof ParameterizedType) { keyClass = (Class) ((ParameterizedType) type).getActualTypeArguments()[0]; valueClass = (Class) ((ParameterizedType) type).getActualTypeArguments()[1]; } // Special case Map<String, String> // Multivalues composite params are binded to a Map<String, String> // see http://play.lighthouseapp.com/projects/57987/tickets/443 if (keyClass == String.class && valueClass == String.class && isComposite(name, params)) { Map<String, String> stringMap = Utils.filterParams(params, name); if (stringMap.size() > 0) return stringMap; } // Search for all params Map<Object, Object> r = new HashMap<Object, Object>(); for (String param : params.keySet()) { Pattern p = Pattern.compile("^" + name + suffix + "\\[([^\\]]+)\\](.*)$"); Matcher m = p.matcher(param); if (m.matches()) { String key = m.group(1); value = params.get(param); Map<String, String[]> tP = new HashMap<String, String[]>(); tP.put("key", new String[] {key}); Object oKey = bindInternal("key", keyClass, keyClass, annotations, tP, "", value); if (oKey != MISSING) { if (isComposite(name + suffix + "[" + key + "]", params)) { BeanWrapper beanWrapper = getBeanWrapper(valueClass); Object oValue = beanWrapper.bind( "", type, params, name + suffix + "[" + key + "]", annotations); r.put(oKey, oValue); } else { tP = new HashMap<String, String[]>(); tP.put("value", params.get(name + suffix + "[" + key + "]")); Object oValue = bindInternal("value", valueClass, valueClass, annotations, tP, "", value); if (oValue != MISSING) { r.put(oKey, oValue); } else { r.put(oKey, null); } } } } } return r; } // Collections types if (Collection.class.isAssignableFrom(clazz)) { if (clazz.isInterface()) { if (clazz.equals(List.class)) { clazz = ArrayList.class; } if (clazz.equals(Set.class)) { clazz = HashSet.class; } if (clazz.equals(SortedSet.class)) { clazz = TreeSet.class; } } Collection r = (Collection) clazz.newInstance(); Class componentClass = String.class; if (type instanceof ParameterizedType) { componentClass = (Class) ((ParameterizedType) type).getActualTypeArguments()[0]; } // Create a an array of the component class if (value != null) { Object customArray = Array.newInstance(componentClass, value.length); // custom types for (Class<?> c : supportedTypes.keySet()) { if (c.isAssignableFrom(customArray.getClass())) { Object[] ar = (Object[]) supportedTypes .get(c) .bind("value", annotations, name, customArray.getClass(), null); List l = Arrays.asList(ar); if (clazz.equals(HashSet.class)) { return new HashSet(l); } else if (clazz.equals(TreeSet.class)) { return new TreeSet(l); } return l; } } } if (value == null) { value = params.get(name + suffix + "[]"); if (value == null && r instanceof List) { for (String param : params.keySet()) { Pattern p = Pattern.compile("^" + escape(name + suffix) + "\\[([0-9]+)\\](.*)$"); Matcher m = p.matcher(param); if (m.matches()) { int key = Integer.parseInt(m.group(1)); while (((List<?>) r).size() <= key) { ((List<?>) r).add(null); } if (isComposite(name + suffix + "[" + key + "]", params)) { BeanWrapper beanWrapper = getBeanWrapper(componentClass); Object oValue = beanWrapper.bind( "", type, params, name + suffix + "[" + key + "]", annotations); ((List) r).set(key, oValue); } else { Map<String, String[]> tP = new HashMap<String, String[]>(); tP.put("value", params.get(name + suffix + "[" + key + "]")); Object oValue = bindInternal( "value", componentClass, componentClass, annotations, tP, "", value); if (oValue != MISSING) { ((List) r).set(key, oValue); } } } } return r.isEmpty() ? MISSING : r; } } if (value == null) { return MISSING; } for (String v : value) { try { r.add(directBind(name, annotations, v, componentClass)); } catch (Exception e) { // ?? One item was bad Logger.debug(e, "error:"); } } return r; } // Assume a Bean if isComposite Logger.trace( "bindInternal: class [" + clazz + "] name [" + name + "] annotation [" + Utils.join(annotations, " ") + "] isComposite [" + isComposite(name + suffix, params) + "]"); if (isComposite(name + suffix, params)) { BeanWrapper beanWrapper = getBeanWrapper(clazz); return beanWrapper.bind(name, type, params, suffix, annotations); } // Simple types if (value == null || value.length == 0) { return MISSING; } return directBind(name, annotations, value[0], clazz, type); } catch (Exception e) { Validation.addError(name + suffix, "validation.invalid"); return MISSING; } }