/** * Returns submap of x and y values according to the given start and end * * @param start start x value * @param stop stop x value * @return a submap of x and y values */ public synchronized SortedMap<Double, Double> getRange( double start, double stop, int beforeAfterPoints) { // we need to add one point before the start and one point after the end (if // there are any) // to ensure that line doesn't end before the end of the screen // this would be simply: start = mXY.lowerKey(start) but NavigableMap is // available since API 9 SortedMap<Double, Double> headMap = mXY.headMap(start); if (!headMap.isEmpty()) { start = headMap.lastKey(); } // this would be simply: end = mXY.higherKey(end) but NavigableMap is // available since API 9 // so we have to do this hack in order to support older versions SortedMap<Double, Double> tailMap = mXY.tailMap(stop); if (!tailMap.isEmpty()) { Iterator<Double> tailIterator = tailMap.keySet().iterator(); Double next = tailIterator.next(); if (tailIterator.hasNext()) { stop = tailIterator.next(); } else { stop += next; } } return new TreeMap<Double, Double>(mXY.subMap(start, stop)); }
public void testDescendingSubMapContents2() { ConcurrentNavigableMap map = dmap5(); SortedMap sm = map.subMap(m2, m3); assertEquals(1, sm.size()); assertEquals(m2, sm.firstKey()); assertEquals(m2, sm.lastKey()); assertFalse(sm.containsKey(m1)); assertTrue(sm.containsKey(m2)); assertFalse(sm.containsKey(m3)); assertFalse(sm.containsKey(m4)); assertFalse(sm.containsKey(m5)); Iterator i = sm.keySet().iterator(); Object k; k = (Integer) (i.next()); assertEquals(m2, k); assertFalse(i.hasNext()); Iterator j = sm.keySet().iterator(); j.next(); j.remove(); assertFalse(map.containsKey(m2)); assertEquals(4, map.size()); assertEquals(0, sm.size()); assertTrue(sm.isEmpty()); assertSame(sm.remove(m3), null); assertEquals(4, map.size()); }
public void testSubMapContents2() { ConcurrentNavigableMap map = map5(); SortedMap sm = map.subMap(two, three); assertEquals(1, sm.size()); assertEquals(two, sm.firstKey()); assertEquals(two, sm.lastKey()); assertFalse(sm.containsKey(one)); assertTrue(sm.containsKey(two)); assertFalse(sm.containsKey(three)); assertFalse(sm.containsKey(four)); assertFalse(sm.containsKey(five)); Iterator i = sm.keySet().iterator(); Object k; k = (Integer) (i.next()); assertEquals(two, k); assertFalse(i.hasNext()); Iterator j = sm.keySet().iterator(); j.next(); j.remove(); assertFalse(map.containsKey(two)); assertEquals(4, map.size()); assertEquals(0, sm.size()); assertTrue(sm.isEmpty()); assertSame(sm.remove(three), null); assertEquals(4, map.size()); }
/** * Returns the number of option values amongst all internal option containers. * * @return the number of option values amongst all internal option containers */ public int getNumberOfOptionValues() { SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet()); union.addAll(dependenciesResolvedOptionMap.keySet()); union.addAll(commandLineOptionMap.keySet()); union.addAll(optionFileOptionMap.keySet()); return union.size(); }
/* (non-Javadoc) * @see java.lang.Object#toString() */ public String toString() { final StringBuilder sb = new StringBuilder(); SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet()); union.addAll(dependenciesResolvedOptionMap.keySet()); union.addAll(commandLineOptionMap.keySet()); union.addAll(optionFileOptionMap.keySet()); for (Option option : union) { Object value = null; for (int i = OptionContainer.SAVEDOPTION; i <= OptionContainer.OPTIONFILE; i++) { if (i == OptionContainer.SAVEDOPTION) { value = savedOptionMap.get(option); } else if (i == OptionContainer.DEPENDENCIES_RESOLVED) { value = dependenciesResolvedOptionMap.get(option); } else if (i == OptionContainer.COMMANDLINE) { value = commandLineOptionMap.get(option); } else if (i == OptionContainer.OPTIONFILE) { value = optionFileOptionMap.get(option); } if (value != null) { break; } } sb.append(option.getGroup().getName() + "\t" + option.getName() + "\t" + value + "\n"); } return sb.toString(); }
public void noMoreInstances() throws MaltChainedException { // if (getGuide().getGuideMode() == Guide.GuideMode.CLASSIFY) { // throw new GuideException("Can only finish all data during learning. "); // } if (divideModels != null) { divideFeature.updateCardinality(); for (Integer index : divideModels.keySet()) { divideModels.get(index).noMoreInstances(); } final TreeSet<Integer> removeSet = new TreeSet<Integer>(); for (Integer index : divideModels.keySet()) { if (divideModels.get(index).getFrequency() <= divideThreshold) { divideModels .get(index) .moveAllInstances(masterModel, divideFeature, divideFeatureIndexVector); removeSet.add(index); } } for (Integer index : removeSet) { divideModels.remove(index); } masterModel.noMoreInstances(); } else { throw new GuideException("The feature divide models cannot be found. "); } }
private void algorithm( int initialSl, SortedMap bslToList, BundleInfo configuratorBInfo, List setToInitialConfig, List setToSimpleConfig, LocationInfo info) { int configuratorSL = configuratorBInfo.getStartLevel(); Integer sL0 = (Integer) bslToList.keySet().iterator().next(); // StartLevel == 0; List list0 = (List) bslToList.get(sL0); if (sL0.intValue() == 0) for (Iterator ite2 = list0.iterator(); ite2.hasNext(); ) { BundleInfo bInfo = (BundleInfo) ite2.next(); if (isSystemBundle(bInfo.getLocation(), info)) { setToSimpleConfig.add(bInfo); break; } } for (Iterator ite = bslToList.keySet().iterator(); ite.hasNext(); ) { Integer sL = (Integer) ite.next(); List list = (List) bslToList.get(sL); if (sL.intValue() < configuratorSL) { for (Iterator ite2 = list.iterator(); ite2.hasNext(); ) { BundleInfo bInfo = (BundleInfo) ite2.next(); if (!isSystemBundle(bInfo.getLocation(), info)) setToInitialConfig.add(bInfo); } } else if (sL.intValue() > configuratorSL) { for (Iterator ite2 = list.iterator(); ite2.hasNext(); ) { BundleInfo bInfo = (BundleInfo) ite2.next(); if (isPrerequisiteBundles(bInfo.getLocation(), info) || isSystemFragmentBundle(bInfo.getLocation(), info)) if (!isSystemBundle(bInfo.getLocation(), info)) setToInitialConfig.add(bInfo); setToSimpleConfig.add(bInfo); } } else { boolean found = false; for (Iterator ite2 = list.iterator(); ite2.hasNext(); ) { BundleInfo bInfo = (BundleInfo) ite2.next(); if (found) { if (!isSystemBundle(bInfo.getLocation(), info)) if (isPrerequisiteBundles(bInfo.getLocation(), info) || isSystemFragmentBundle(bInfo.getLocation(), info)) setToInitialConfig.add(bInfo); setToSimpleConfig.add(bInfo); continue; } if (isTargetConfiguratorBundle(bInfo.getLocation())) found = true; else if (!isSystemBundle(bInfo.getLocation(), info)) setToInitialConfig.add(bInfo); setToSimpleConfig.add(bInfo); } } } setToInitialConfig.add(configuratorBInfo); }
private boolean logPropertyDifferences( String message, SortedMap<String, Class> prevMap, SortedMap<String, Class> newMap) { boolean foundDifference = false; for (String prevKey : prevMap.keySet()) { if (nonVersionSpecificAttributes.contains(prevKey)) continue; Class prevClass = prevMap.get(prevKey); Class newClass = newMap.get(prevKey); if (prevClass != null && prevClass != newClass) { if (newClass == null) { if (!foundDifference) { log.info(message); foundDifference = true; } log.info( "\tnew event missing field in prev event: %s = %s", prevKey, prevClass.getSimpleName()); } else { if (!foundDifference) { log.info(message); foundDifference = true; } // should fail in subsequent esper update anyway log.warn( "\tnew event has new type for %s, prev: %s, new: %s", prevKey, prevClass.getSimpleName(), newClass.getSimpleName()); } } } for (String newKey : newMap.keySet()) { if (nonVersionSpecificAttributes.contains(newKey)) continue; Class newClass = newMap.get(newKey); Class prevClass = prevMap.get(newKey); if (newClass != null && prevClass != newClass) { if (prevClass == null) { if (!foundDifference) { log.info(message); foundDifference = true; } log.info("\tnew event has new field: %s = %s", newKey, newClass.getSimpleName()); } } } return foundDifference; }
/** writes activity type to typical activity duration to file. */ private void writeTypicalAndMinimumActivityDurations(final String configFile) { Config config = new Config(); config.addCoreModules(); ConfigReader reader = new ConfigReader(config); reader.readFile(configFile); SortedMap<String, Double> act2TypDur = new TreeMap<>(); SortedMap<String, Double> act2MinDur = new TreeMap<>(); for (String actTyp : config.planCalcScore().getActivityTypes()) { act2TypDur.put(actTyp, config.planCalcScore().getActivityParams(actTyp).getTypicalDuration()); act2MinDur.put(actTyp, config.planCalcScore().getActivityParams(actTyp).getMinimalDuration()); } String fileName = outputDir + "/analysis/actTyp2TypicalAndMinimumActDurations.txt"; BufferedWriter writer = IOUtils.getBufferedWriter(fileName); try { writer.write("actType \t typicalActDuration \t minimumActDuration \n"); for (String actTyp : act2MinDur.keySet()) { writer.write(actTyp + "\t" + act2TypDur.get(actTyp) + "\t" + act2MinDur.get(actTyp) + "\n"); } writer.close(); } catch (Exception e) { throw new RuntimeException("Data is not written. Reason - " + e); } ActivityType2DurationHandler.LOG.info("Data is written to file " + fileName); }
private String createParameterString() { // put required parameters for (OauthConstants constant : OauthConstants.values()) { String key = OAuth.percentEncode(constant.name()); String value = OAuth.percentEncode(properties.getProperty(constant.name())); if (constant.equals(OauthConstants.oauth_nonce)) { value = OAuth.percentEncode(nonce); } if (constant.equals(OauthConstants.oauth_timestamp)) { value = OAuth.percentEncode(String.valueOf(timestamp)); } parameterMap.put(key, value); } // put optional parameters for (Object key_ : optionalParameters.keySet()) { String keyStr = (String) key_; String key = OAuth.percentEncode(keyStr); String value = OAuth.percentEncode(optionalParameters.get(keyStr).toString()); parameterMap.put(key, value); } StringBuilder builder = new StringBuilder(); for (String s : parameterMap.keySet()) { builder.append(s).append('=').append(parameterMap.get(s)).append("&"); } builder.setLength(builder.lastIndexOf("&")); return builder.toString(); }
private Integer getBin(SortedMap<Integer, Integer[]> distribution, Double distance) { Integer bin = distribution.firstKey(); for (Integer nextBin : distribution.keySet()) if (distance < nextBin) return bin; else bin = nextBin; return bin; }
/** * Pushes a new Construct onto the end of the array. If the index is specified, this works like a * "insert" operation, in that all values are shifted to the right, starting with the value at * that index. If the array is associative though, you MUST send null, otherwise an {@link * IllegalArgumentException} is thrown. Ideally, you should use {@link #set} anyways for an * associative array. * * @param c The Construct to add to the array * @throws IllegalArgumentException If index is not null, and this is an associative array. * @throws IndexOutOfBoundsException If the index is not null, and the index specified is out of * range. */ public void push(Construct c, Integer index, Target t) throws IllegalArgumentException, IndexOutOfBoundsException { if (!associative_mode) { if (index != null) { array.add(index, c); } else { array.add(c); } next_index++; } else { if (index != null) { throw new IllegalArgumentException("Cannot insert into an associative array"); } int max = 0; for (String key : associative_array.keySet()) { try { int i = Integer.parseInt(key); max = java.lang.Math.max(max, i); } catch (NumberFormatException e) { } } if (c instanceof CEntry) { associative_array.put(Integer.toString(max + 1), ((CEntry) c).construct()); } else { associative_array.put(Integer.toString(max + 1), c); } } if (c instanceof CArray) { ((CArray) c).parent = this; } regenValue(new HashSet<CArray>()); }
public CArray(Target t, int initialCapacity, Construct... items) { super("{}", ConstructType.ARRAY, t); if (initialCapacity == -1) { associative_mode = true; } else if (items != null) { for (Construct item : items) { if (item instanceof CEntry) { // it's an associative array associative_mode = true; break; } } } associative_array = new TreeMap<>(comparator); array = associative_mode ? new ArrayList<Construct>() : initialCapacity > 0 ? new ArrayList<Construct>(initialCapacity) : items != null ? new ArrayList<Construct>(items.length) : new ArrayList<Construct>(); if (associative_mode) { if (items != null) { for (Construct item : items) { if (item instanceof CEntry) { associative_array.put( normalizeConstruct(((CEntry) item).ckey), ((CEntry) item).construct); } else { int max = Integer.MIN_VALUE; for (String key : associative_array.keySet()) { try { int i = Integer.parseInt(key); max = java.lang.Math.max(max, i); } catch (NumberFormatException e) { } } if (max == Integer.MIN_VALUE) { max = -1; // Special case, there are no integer indexes in here yet. } associative_array.put(Integer.toString(max + 1), item); if (item instanceof CArray) { ((CArray) item).parent = this; } } } } } else { if (items != null) { for (Construct item : items) { array.add(item); if (item instanceof CArray) { ((CArray) item).parent = this; } } } this.next_index = array.size(); } regenValue(new HashSet<CArray>()); }
public static Combo createEncodingCombo(Composite parent, String curCharset) { if (curCharset == null) { curCharset = GeneralUtils.getDefaultFileEncoding(); } Combo encodingCombo = new Combo(parent, SWT.DROP_DOWN); encodingCombo.setVisibleItemCount(30); SortedMap<String, Charset> charsetMap = Charset.availableCharsets(); int index = 0; int defIndex = -1; for (String csName : charsetMap.keySet()) { Charset charset = charsetMap.get(csName); encodingCombo.add(charset.displayName()); if (charset.displayName().equalsIgnoreCase(curCharset)) { defIndex = index; } if (defIndex < 0) { for (String alias : charset.aliases()) { if (alias.equalsIgnoreCase(curCharset)) { defIndex = index; } } } index++; } if (defIndex >= 0) { encodingCombo.select(defIndex); } else { log.warn("Charset '" + curCharset + "' is not recognized"); // $NON-NLS-1$ //$NON-NLS-2$ } return encodingCombo; }
private void resolveFields() { for (Method method : objectType.getMethods()) { if ((method.getModifiers() & Modifier.STATIC) != 0) { continue; } String fieldName = null; if (method.getName().startsWith("get")) { if (method.getName().equals("getId") || method.getName().length() <= 3) { continue; } // Found a field! fieldName = getFieldName(method.getName()); } else if (method.getName().startsWith("is")) { if (method.getName().length() <= 2) { continue; } // Found a field! fieldName = getFieldName(method.getName()); } if (fieldName != null) { fieldTypeMap.put(fieldName, method.getReturnType()); } } int index = 0; for (String fieldName : fieldTypeMap.keySet()) { fieldIndexMap.put(fieldName, index++); } }
/** Map from char */ public char map(char src) { // find first segment with endcode > src for (Iterator i = segments.keySet().iterator(); i.hasNext(); ) { Segment s = (Segment) i.next(); if (s.endCode >= src) { // are we within range? if (s.startCode <= src) { if (s.hasMap) { // return the index of this character in // the segment's map char[] map = (char[]) segments.get(s); return map[src - s.startCode]; } else { // return the character code + idDelta Integer idDelta = (Integer) segments.get(s); return (char) (src + idDelta.intValue()); } } else { // undefined character return (char) 0; } } } // shouldn't get here! return (char) 0; }
/** Get the src code which maps to the given glyphID */ public char reverseMap(short glyphID) { // look at each segment for (Iterator i = segments.keySet().iterator(); i.hasNext(); ) { Segment s = (Segment) i.next(); // see if we have a map or a delta if (s.hasMap) { char[] map = (char[]) segments.get(s); // if we have a map, we have to iterate through it for (int c = 0; c < map.length; c++) { if (map[c] == glyphID) { return (char) (s.startCode + c); } } } else { Integer idDelta = (Integer) segments.get(s); // we can do the math to see if we're in range int start = s.startCode + idDelta.intValue(); int end = s.endCode + idDelta.intValue(); if (glyphID >= start && glyphID <= end) { // we're in the range return (char) (glyphID - idDelta.intValue()); } } } // not found! return (char) 0; }
public String[] getStocksInPortfolio() { Set<String> ids = stockmap.keySet(); String[] result = new String[ids.size()]; int i = 0; for (String s : ids) result[i++] = s; return result; }
public static PackageInfo[] chooseModulePackages() { ClassInfo[] classes = Converter.rootClasses(); SortedMap<String, PackageInfo> sorted = new TreeMap<String, PackageInfo>(); for (ClassInfo cl : classes) { if (!cl.isModule()) { continue; } PackageInfo pkg = cl.containingPackage(); String name; if (pkg == null) { name = ""; } else { name = pkg.name(); } sorted.put(name, pkg); } ArrayList<PackageInfo> result = new ArrayList<PackageInfo>(); for (String s : sorted.keySet()) { PackageInfo pkg = sorted.get(s); result.add(pkg); } return result.toArray(new PackageInfo[result.size()]); }
public boolean next(SubRequest request) { MOScope scope = request.getQuery().getScope(); SortedMap<OID, Variable> tail = vbs.tailMap(scope.getLowerBound()); OID first = tail.firstKey(); if (scope.getLowerBound().equals(first) && (!scope.isLowerIncluded())) { if (tail.size() > 1) { Iterator<OID> it = tail.keySet().iterator(); it.next(); first = it.next(); } else { return false; } } if (first != null) { Variable vb = vbs.get(first); if (vb == null) { request.getVariableBinding().setVariable(Null.noSuchInstance); } request.getVariableBinding().setOid(first); request.getVariableBinding().setVariable(vb); request.completed(); return true; } return false; }
/** * Construct a Strategy that parses a TimeZone * * @param locale The Locale */ TimeZoneStrategy(final Locale locale) { final String[][] zones = DateFormatSymbols.getInstance(locale).getZoneStrings(); for (String[] zone : zones) { if (zone[ID].startsWith("GMT")) { continue; } final TimeZone tz = TimeZone.getTimeZone(zone[ID]); if (!tzNames.containsKey(zone[LONG_STD])) { tzNames.put(zone[LONG_STD], tz); } if (!tzNames.containsKey(zone[SHORT_STD])) { tzNames.put(zone[SHORT_STD], tz); } if (tz.useDaylightTime()) { if (!tzNames.containsKey(zone[LONG_DST])) { tzNames.put(zone[LONG_DST], tz); } if (!tzNames.containsKey(zone[SHORT_DST])) { tzNames.put(zone[SHORT_DST], tz); } } } final StringBuilder sb = new StringBuilder(); sb.append("(GMT[+\\-]\\d{0,1}\\d{2}|[+\\-]\\d{2}:?\\d{2}|"); for (final String id : tzNames.keySet()) { escapeRegex(sb, id, false).append('|'); } sb.setCharAt(sb.length() - 1, ')'); validTimeZoneChars = sb.toString(); }
public void dumpHeader(TabbedPrintWriter writer) throws java.io.IOException { writer.println("/* " + className + " - Decompiled by JODE"); writer.println(" * Visit " + GlobalOptions.URL); writer.println(" */"); if (pkg.length() != 0) writer.println("package " + pkg + ";"); cleanUpImports(); Iterator iter = imports.keySet().iterator(); String lastFirstPart = null; while (iter.hasNext()) { String pkgName = (String) iter.next(); if (!pkgName.equals("java.lang.*")) { int firstDot = pkgName.indexOf('.'); if (firstDot != -1) { String firstPart = pkgName.substring(0, firstDot); if (lastFirstPart != null && !lastFirstPart.equals(firstPart)) { writer.println(""); } lastFirstPart = firstPart; } writer.println("import " + pkgName + ";"); } } writer.println(""); }
/** * Method that combines the fingerprint evidence across all the read groups for the same sample * and then produces a matrix of LOD scores for comparing every sample with every other sample. */ private void crossCheckSamples(final List<Fingerprint> fingerprints, final PrintStream out) { final SortedMap<String, Fingerprint> sampleFps = FingerprintChecker.mergeFingerprintsBySample(fingerprints); final SortedSet<String> samples = (SortedSet<String>) sampleFps.keySet(); // Print header row out.print("\t"); for (final String sample : samples) { out.print(sample); out.print("\t"); } out.println(); // Print results rows for (final String sample : samples) { out.print(sample); final Fingerprint fp = sampleFps.get(sample); for (final String otherSample : samples) { final MatchResults results = FingerprintChecker.calculateMatchResults( fp, sampleFps.get(otherSample), GENOTYPING_ERROR_RATE, LOSS_OF_HET_RATE); out.print("\t"); out.print(formatUtil.format(results.getLOD())); } out.println(); } }
@Test public void testOrderBy() { final JPAEnvironment env = getEnvironment(); final EntityManager em = env.getEntityManager(); final SortedMap<String, Employee> attendeeMap = new TreeMap<String, Employee>(); try { env.beginTransaction(em); final Course course = createAndPersistCourse(em); final Long courseId = Long.valueOf(course.getCourseId()); final Employee employee1 = em.find(Employee.class, EMP_ID_DORIS); attendeeMap.put(employee1.getLastName(), employee1); final Employee employee2 = em.find(Employee.class, EMP_ID_SABINE); attendeeMap.put(employee2.getLastName(), employee2); env.commitTransactionAndClear(em); env.beginTransaction(em); final Course storedCourse = em.find(Course.class, courseId); verify(storedCourse != null, "didnt find course again"); final List<Employee> attendees = storedCourse.getAttendees(); verify(attendees != null, "course lost attendees"); final Iterator<Employee> orderedEmployees = attendees.iterator(); for (final String lastName : attendeeMap.keySet()) { Employee nextEmployee = orderedEmployees.next(); verify( nextEmployee.getLastName().equals(lastName), "wrong order of employees, expected name: " + lastName + ", but got name: " + nextEmployee.getLastName()); } env.commitTransactionAndClear(em); } finally { closeEntityManager(em); } }
/** Get a pretty string */ @Override public String toString() { StringBuffer buf = new StringBuffer(); String indent = " "; buf.append(super.toString()); buf.append(indent + "SegmentCount : " + getSegmentCount() + "\n"); buf.append(indent + "SearchRange : " + getSearchRange() + "\n"); buf.append(indent + "EntrySelector: " + getEntrySelector() + "\n"); buf.append(indent + "RangeShift : " + getRangeShift() + "\n"); for (Iterator i = segments.keySet().iterator(); i.hasNext(); ) { Segment s = (Segment) i.next(); buf.append(indent); buf.append("Segment: " + Integer.toHexString(s.startCode)); buf.append("-" + Integer.toHexString(s.endCode) + " "); buf.append("hasMap: " + s.hasMap + " "); if (!s.hasMap) { buf.append("delta: " + segments.get(s)); } buf.append("\n"); } return buf.toString(); }
/* * values[]: the alphabet (provided as Integers) bitLengths[]: the number of * bits of symbil's huffman code */ public CanonicalHuffmanIntegerCodec(int[] values, int[] bitLengths) { super(); // 1. Sort by (a) bit length and (b) by symbol value ----------- SortedMap codebook = new TreeMap<Integer, SortedSet<Integer>>(); for (int i = 0; i < values.length; i++) { if (codebook.containsKey(bitLengths[i])) ((TreeSet) codebook.get(bitLengths[i])).add(values[i]); else { TreeSet<Integer> entry = new TreeSet<Integer>(); entry.add(values[i]); codebook.put(bitLengths[i], entry); } } codeLentghSorted = new Integer[codebook.size()]; int keys = 0; // 2. Calculate and Assign Canonical Huffman Codes ------------- int codeLength = 0, codeValue = -1; // first Canonical is always 0 codes = new TreeMap<Integer, HuffmanBitCode>(); Set keySet = codebook.keySet(); for (Object key : keySet) { // Iterate over code lengths int iKey = Integer.parseInt(key.toString()); codeLentghSorted[keys++] = iKey; TreeSet<Integer> get = (TreeSet<Integer>) codebook.get(key); for (Integer entry : get) { // Iterate over symbols HuffmanBitCode code = new HuffmanBitCode(); code.bitLentgh = iKey; // given: bit length code.value = entry; // given: symbol codeValue++; // increment bit value by 1 int delta = iKey - codeLength; // new length? codeValue = codeValue << delta; // pad with 0's code.bitCode = codeValue; // calculated: huffman code codeLength += delta; // adjust current code len if (NumberOfSetBits(codeValue) > iKey) throw new IllegalArgumentException("Symbol out of range"); codes.put(entry, code); // Store HuffmanBitCode Map<Long, Integer> codeMap = codeCache.get(code.bitLentgh); if (codeMap == null) { codeMap = new HashMap<Long, Integer>(); codeCache.put(code.bitLentgh, codeMap); } codeMap.put(new Long(code.bitCode), code.value); } } // 3. Done. Just have to populate codeMaps --------------------- if (codeLentghSorted.length > 0) codeMaps = new Map[codeLentghSorted[codeLentghSorted.length - 1] + 1]; else codeMaps = new Map[1]; for (int len : codeLentghSorted) { // Iterate over code lengths codeMaps[len] = codeCache.get(len); } }
@Test public void testAssignMigrations() { servers.clear(); servers.put( new TServerInstance(HostAndPort.fromParts("127.0.0.1", 1234), "a"), new FakeTServer()); servers.put( new TServerInstance(HostAndPort.fromParts("127.0.0.1", 1235), "b"), new FakeTServer()); servers.put( new TServerInstance(HostAndPort.fromParts("127.0.0.1", 1236), "c"), new FakeTServer()); List<KeyExtent> metadataTable = new ArrayList<KeyExtent>(); String table = "t1"; metadataTable.add(makeExtent(table, null, null)); table = "t2"; metadataTable.add(makeExtent(table, "a", null)); metadataTable.add(makeExtent(table, null, "a")); table = "t3"; metadataTable.add(makeExtent(table, "a", null)); metadataTable.add(makeExtent(table, "b", "a")); metadataTable.add(makeExtent(table, "c", "b")); metadataTable.add(makeExtent(table, "d", "c")); metadataTable.add(makeExtent(table, "e", "d")); metadataTable.add(makeExtent(table, null, "e")); Collections.sort(metadataTable); TestDefaultLoadBalancer balancer = new TestDefaultLoadBalancer(); SortedMap<TServerInstance, TabletServerStatus> current = new TreeMap<TServerInstance, TabletServerStatus>(); for (Entry<TServerInstance, FakeTServer> entry : servers.entrySet()) { current.put(entry.getKey(), entry.getValue().getStatus(entry.getKey())); } assignTablets(metadataTable, servers, current, balancer); // Verify that the counts on the tables are correct Map<String, Integer> expectedCounts = new HashMap<String, Integer>(); expectedCounts.put("t1", 1); expectedCounts.put("t2", 1); expectedCounts.put("t3", 2); checkBalance(metadataTable, servers, expectedCounts); // Rebalance once for (Entry<TServerInstance, FakeTServer> entry : servers.entrySet()) { current.put(entry.getKey(), entry.getValue().getStatus(entry.getKey())); } // Nothing should happen, we are balanced ArrayList<TabletMigration> out = new ArrayList<TabletMigration>(); balancer.getMigrations(current, out); assertEquals(out.size(), 0); // Take down a tabletServer TServerInstance first = current.keySet().iterator().next(); current.remove(first); FakeTServer remove = servers.remove(first); // reassign offline extents assignTablets(remove.extents, servers, current, balancer); checkBalance(metadataTable, servers, null); }
// TODO obj private SortedMap<Date, Double> sCalcOutput(SortedMap<Date, double[]> calcOutput) { SortedMap<Date, Double> sCalcOutput = new TreeMap<Date, Double>(); for (Date date : calcOutput.keySet()) { sCalcOutput.put(date, calcOutput.get(date)[0]); } return sCalcOutput; }
@Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { Log.i( AbstractCollectionProvider.cTag, "Upgrading database from version " + oldVersion + " to " + newVersion); SortedMap<Integer, Migration> migrations = ALL_MIGRATIONS.subMap(oldVersion, newVersion); executeMigrations(db, migrations.keySet()); }
private void cleanUpImports() { Integer dummyVote = new Integer(Integer.MAX_VALUE); SortedMap newImports = new TreeMap(comparator); List classImports = new LinkedList(); Iterator iter = imports.keySet().iterator(); while (iter.hasNext()) { String importName = (String) iter.next(); Integer vote = (Integer) imports.get(importName); if (!importName.endsWith(".*")) { if (vote.intValue() < importClassLimit) continue; int delim = importName.lastIndexOf("."); if (delim != -1) { /* * Since the imports are sorted, newImports already contains * the package if it should be imported. */ if (newImports.containsKey(importName.substring(0, delim) + ".*")) continue; /* * This is a single Class import, that is not superseeded by * a package import. Mark it for importation, but don't put * it in newImports, yet. */ classImports.add(importName); } else if (pkg.length() != 0) { /* * This is a Class import from the unnamed package. It must * always be imported. */ newImports.put(importName, dummyVote); } } else { if (vote.intValue() < importPackageLimit) continue; newImports.put(importName, dummyVote); } } imports = newImports; cachedClassNames = new Hashtable(); /* * Now check if the class import conflict with any of the package * imports. */ iter = classImports.iterator(); while (iter.hasNext()) { /* * If there are more than one single class imports with the same * name, exactly the first (in sorted order) will be imported. */ String classFQName = (String) iter.next(); if (!conflictsImport(classFQName)) { imports.put(classFQName, dummyVote); String name = classFQName.substring(classFQName.lastIndexOf('.') + 1); cachedClassNames.put(classFQName, name); } } }