Java Code Examples for java.util.SortedMap#get()

public String hashJob(int jobId, List<String> addressList) {

        // ------A1------A2-------A3------
        // -----------J1------------------
        TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
        for (String address: addressList) {
            for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
                long addressHash = hash("SHARD-" + address + "-NODE-" + i);
                addressRing.put(addressHash, address);
            }
        }

        long jobHash = hash(String.valueOf(jobId));
        SortedMap<Long, String> lastRing = addressRing.tailMap(jobHash);
        if (!lastRing.isEmpty()) {
            return lastRing.get(lastRing.firstKey());
        }
        return addressRing.firstEntry().getValue();
    }
 

public static void main(String[] args) throws IOException {
    SortedMap<String, Charset> map = Charset.availableCharsets();
    for (String name : map.keySet()) {
        Charset charset = map.get(name);
        if (charset.canEncode() && !charset.name().equals("x-COMPOUND_TEXT")) {
            testNormalSurrogate(charset, NORMAL_SURROGATE);
            testMalformedSurrogate(charset, MALFORMED_SURROGATE);
            testMalformedSurrogate(charset, REVERSED_SURROGATE);
            testMalformedSurrogate(charset, SOLITARY_HIGH_SURROGATE);
            testMalformedSurrogate(charset, SOLITARY_LOW_SURROGATE);
            testSurrogateWithReplacement(charset, NORMAL_SURROGATE);
            testSurrogateWithReplacement(charset, MALFORMED_SURROGATE);
            testSurrogateWithReplacement(charset, REVERSED_SURROGATE);
            testSurrogateWithReplacement(charset, SOLITARY_HIGH_SURROGATE);
            testSurrogateWithReplacement(charset, SOLITARY_LOW_SURROGATE);
        }
    }
}
 

private static void assignOrphans(
        String topicName, SortedMap<Integer, Node> nodeMap,
        Map<Integer, Integer> orphanedReplicas) {
    // Don't process nodes in the same order for all topics to ensure that topics with fewer
    // replicas than nodes are equally likely to be assigned anywhere (and not overload the
    // brokers with earlier IDs).
    Integer[] nodeProcessingOrder = getNodeProcessingOrder(topicName, nodeMap.keySet());
    List<Integer> nodeProcessingOrderList = Arrays.asList(nodeProcessingOrder);

    // Assign unassigned replicas to nodes that can accept them
    for (Map.Entry<Integer, Integer> e : orphanedReplicas.entrySet()) {
        int partition = e.getKey();
        int remainingReplicas = e.getValue();
        Iterator<Integer> nodeIt = nodeProcessingOrderList.iterator();
        while (nodeIt.hasNext() && remainingReplicas > 0) {
            Node node = nodeMap.get(nodeIt.next());
            if (node.canAccept(partition)) {
                node.accept(partition);
                remainingReplicas--;
            }
        }
        Preconditions.checkState(remainingReplicas == 0, "Partition " + partition +
                " could not be fully assigned!");
    }
}
 

@Test
public void testOneInRange() {
    // 12 AM - 1 AM
    long start_time_ms = new DateTime(2000, 1, 1, 0, 0, 0, 0, DTZ).getMillis();
    long start_time_s = TimeUnit.MILLISECONDS.toSeconds(start_time_ms);
    long end_time_ms = start_time_ms + TimeUnit.HOURS.toMillis(1);
    long end_time_s = TimeUnit.MILLISECONDS.toSeconds(end_time_ms);
    AgendaItem item = new AgendaItem();
    item.setEpochStartTime(start_time_s);
    item.setEpochEndTime(end_time_s);

    long look_ahead = TimeUnit.DAYS.toMillis(1);
    long now = start_time_ms - look_ahead + 1;  // Just inside of range
    final List<AgendaItem> items_in = Collections.singletonList(item);
    final SortedMap<DateRange, List<AgendaItem>> map =
        AgendaItems.upNext(items_in, now, TimeUnit.DAYS.toMillis(1), 0);

    assertEquals(1, map.size());
    final DateRange dr = map.firstKey();
    assertNotNull(dr);
    assertEquals(start_time_ms, dr.start);
    assertEquals(end_time_ms, dr.end);
    final List<AgendaItem> items_out = map.get(dr);
    assertEquals(1, items_out.size());
    assertSame(item, items_out.get(0));
}
 

@Override
protected boolean matchesSafely(
    ConvertConfigurationAnswerElement item, Description mismatchDescription) {
  SortedMap<String, SortedMap<String, SortedMap<String, DefinedStructureInfo>>> byFile =
      item.getDefinedStructures();
  if (!byFile.containsKey(_filename)) {
    mismatchDescription.appendText(
        String.format("File '%s' has no defined structures", _filename));
    return false;
  }
  SortedMap<String, SortedMap<String, DefinedStructureInfo>> byType = byFile.get(_filename);
  if (!byType.containsKey(_type)) {
    mismatchDescription.appendText(
        String.format("File '%s' has no defined structure of type '%s'", _filename, _type));
    return false;
  }
  SortedMap<String, DefinedStructureInfo> byStructureName = byType.get(_type);
  if (!byStructureName.containsKey(_structureName)) {
    mismatchDescription.appendText(
        String.format(
            "File '%s' has no defined structure of type '%s' named '%s'",
            _filename, _type, _structureName));
    return false;
  }
  return true;
}
 

@Override
protected boolean matchesSafely(
    ConvertConfigurationAnswerElement item, Description mismatchDescription) {
  SortedMap<String, SortedMap<String, SortedMap<String, SortedMap<String, SortedSet<Integer>>>>>
      byFile = item.getUndefinedReferences();
  if (!byFile.containsKey(_filename)) {
    mismatchDescription.appendText(
        String.format("File '%s' has no undefined references", _filename));
    return false;
  }
  SortedMap<String, SortedMap<String, SortedMap<String, SortedSet<Integer>>>> byType =
      byFile.get(_filename);
  if (!byType.containsKey(_type)) {
    mismatchDescription.appendText(
        String.format(
            "File '%s' has no undefined references to structures of type '%s'",
            _filename, _type));
    return false;
  }
  SortedMap<String, SortedMap<String, SortedSet<Integer>>> byStructureName = byType.get(_type);
  if (!byStructureName.containsKey(_structureName)) {
    mismatchDescription.appendText(
        String.format(
            "File '%s' has no undefined references to structures of type '%s' named '%s'",
            _filename, _type, _structureName));
    return false;
  }
  SortedMap<String, SortedSet<Integer>> byUsage = byStructureName.get(_structureName);
  if (!byUsage.containsKey(_usage)) {
    mismatchDescription.appendText(
        String.format(
            "File '%s' has no undefined references to structures of type '%s' named '%s' of "
                + "usage '%s'",
            _filename, _type, _structureName, _usage));
    return false;
  }
  return true;
}
 

@Test
public void testAtStartOfTwoSameRange() {
    // 12 AM - 1 AM
    long start_time_ms = new DateTime(2000, 1, 1, 0, 0, 0, 0, DTZ).getMillis();
    long start_time_s = TimeUnit.MILLISECONDS.toSeconds(start_time_ms);
    long end_time_ms = start_time_ms + TimeUnit.HOURS.toMillis(1);
    long end_time_s = TimeUnit.MILLISECONDS.toSeconds(end_time_ms);
    AgendaItem item0 = new AgendaItem();
    item0.setEpochStartTime(start_time_s);
    item0.setEpochEndTime(end_time_s);
    AgendaItem item1 = new AgendaItem();
    item1.setEpochStartTime(start_time_s);
    item1.setEpochEndTime(end_time_s);

    final List<AgendaItem> items_in = Arrays.asList(item0, item1);
    final SortedMap<DateRange, List<AgendaItem>> map =
        AgendaItems.happeningNow(items_in, start_time_ms);

    assertEquals(1, map.size());
    final DateRange dr = map.firstKey();
    assertNotNull(dr);
    assertEquals(start_time_ms, dr.start);
    assertEquals(end_time_ms, dr.end);
    final List<AgendaItem> items_out = map.get(dr);
    assertEquals(2, items_out.size());
    assertSame(item0, items_out.get(0));
    assertSame(item1, items_out.get(1));
}
 

/**
 * This is the function that re-groups values for a key into sub-groups based
 * on a secondary key (input tag).
 * 
 * @param arg1
 * @return
 */
private SortedMap<Object, ResetableIterator> regroup(Object key,
                                                     Iterator arg1, Reporter reporter) throws IOException {
  this.numOfValues = 0;
  SortedMap<Object, ResetableIterator> retv = new TreeMap<Object, ResetableIterator>();
  TaggedMapOutput aRecord = null;
  while (arg1.hasNext()) {
    this.numOfValues += 1;
    if (this.numOfValues % 100 == 0) {
      reporter.setStatus("key: " + key.toString() + " numOfValues: "
                         + this.numOfValues);
    }
    if (this.numOfValues > this.maxNumOfValuesPerGroup) {
      continue;
    }
    aRecord = ((TaggedMapOutput) arg1.next()).clone(job);
    Text tag = aRecord.getTag();
    ResetableIterator data = retv.get(tag);
    if (data == null) {
      data = createResetableIterator();
      retv.put(tag, data);
    }
    data.add(aRecord);
  }
  if (this.numOfValues > this.largestNumOfValues) {
    this.largestNumOfValues = numOfValues;
    LOG.info("key: " + key.toString() + " this.largestNumOfValues: "
             + this.largestNumOfValues);
  }
  return retv;
}
 

@Test
public void validateCreatingDependencyInformationMapFromDependencyPropertiesFile() {

    // Assemble
    final String jaxbApiKey = "javax.xml.bind/jaxb-api";
    final URL depsPropResource = getClass().getResource(DEPS1_PROPERTYFILE);

    // Act
    final SortedMap<String, String> versionMap = DependsFileParser.getVersionMap(depsPropResource);
    final SortedMap<String, DependencyInfo> diMap = DependsFileParser.createDependencyInfoMap(versionMap);

    // Assert
    final DependencyInfo dependencyInfo = diMap.get(jaxbApiKey);
    Assert.assertNotNull(dependencyInfo);

    Assert.assertEquals("javax.xml.bind", dependencyInfo.getGroupId());
    Assert.assertEquals("jaxb-api", dependencyInfo.getArtifactId());
    Assert.assertEquals("2.2.11", dependencyInfo.getVersion());
    Assert.assertEquals("jar", dependencyInfo.getType());
    Assert.assertEquals("compile", dependencyInfo.getScope());

    /*
    for(Map.Entry<String, DependencyInfo> current : diMap.entrySet()) {
        System.out.println(" [" + current.getKey() + "]: " + current.getValue());
    }
    */
}
 

/**
 * This function seeks forward using all "available" bytes.
 * It returns the offset after the seek.
 *
 * This function throws EOFException if there are no available complete metaDataBlock
 * or the metaDataBlock points to a position after the file end (e.g. truncated files).
 */
public long seekForward() throws IOException {
  // Try to read the last metadata block
  interleavedIn.skipToLastAvailableMetaDataBlock();
  if (!interleavedIn.readMetaDataIfNeeded()) {
    throw new EOFException("Cannot get a complete metadata block");
  }

  // Move the interleavedIn to the beginning of a dataSegment
  SortedMap<Long, Long> offsetPairs = metaData.getOffsetPairs();
  // The last key in the offsetPair points to the farthest position that we can seek to.
  long uncompressedDataOffset = offsetPairs.lastKey();
  long compressedDataOffset = offsetPairs.get(uncompressedDataOffset);
  long toSkip = compressedDataOffset - interleavedIn.getDataOffset();
  if (toSkip < 0) {
    throw new CorruptedDataException("SSF format error: The last offset pair is before the current position in InterleaveStream!");
  }
  try {
    interleavedIn.skipExactly(toSkip);
  } catch (EOFException e) {
    // Ignore this exception
    // This is the PTail use case.  We don't care about this CodecPrematureEOFException
  }

  clearDataSegment();
  return uncompressedDataOffset;
}
 

private void verifyEntriesReleased(SortedMap<Long, ByteBuf> entries,
                                   long startSequenceId,
                                   int numEntriesToRead) {
    for (int i = 0; i < numEntriesToRead; i++) {
        long sequenceId = startSequenceId + i;
        ByteBuf bb = entries.get(sequenceId);
        assertNotNull(bb);
        assertEquals(bb.refCnt(), 0);
    }
}
 

private void addCounters(SortedMap<String, Counter> counters, LinkedList<PutMetricDataRequest> requests, Date timestamp) {
    logger.debug("Adding Counters...");
    for (String name : counters.keySet()) {
        Counter counter = counters.get(name);
        addDatum(filter.getMatchingMetricDescriptor(name, Stat.ALL).getAlias(), counter.getCount(), requests, timestamp);
    }
}
 

/**
 * Create the header of the global partwise, by replicating information
 * form first page header
 *
 * @param global the global partwise to update
 * @param pages  the individual page partwise instances
 */
private void addHeader (ScorePartwise global,
                        SortedMap<Integer, ScorePartwise> pages)
{
    //
    //  <!ENTITY % score-header
    //          "(work?, movement-number?, movement-title?,
    //            identification?, defaults?, credit*, part-list)">
    //

    // First page data
    ScorePartwise first = pages.get(pages.firstKey());

    // work?
    if (first.getWork() != null) {
        global.setWork(first.getWork());
    }

    // movement-number?
    if (first.getMovementNumber() != null) {
        global.setMovementNumber(first.getMovementNumber());
    }

    // movement-title?
    if (first.getMovementTitle() != null) {
        global.setMovementTitle(first.getMovementTitle());
    }

    // identification?
    if (first.getIdentification() != null) {
        // TODO Encoding:
        // - Signature is inserted twice (page then global)
        // - Source should be the whole score file, not the first page file
        global.setIdentification(first.getIdentification());
    }

    // defaults?
    if (first.getDefaults() != null) {
        global.setDefaults(first.getDefaults());
    }

    // credit(s) for first page and others as well
    for (Entry<Integer, ScorePartwise> entry : pages.entrySet()) {
        int index = entry.getKey();
        ScorePartwise page = entry.getValue();
        List<Credit> credits = page.getCredit();

        if (!credits.isEmpty()) {
            // Add page index
            insertPageIndex(index, credits);
            global.getCredit().addAll(credits);
        }
    }
}
 

/**
 * Returns a map of effective logging levels for SIS loggers. The effective logging level take in account the level
 * of parent loggers and the level of handlers. For example if a logger level is set to {@link Level#FINE} but no
 * handler have a level finer than {@link Level#INFO}, then the effective logging level will be {@link Level#INFO}.
 *
 * <p>This method does not report the loggers that have an effective level identical to its parent logger.</p>
 *
 * @return the effective logging levels of SIS loggers.
 */
public static SortedMap<String,Level> getEffectiveLevels() {
    final SortedMap<String,Level> levels = new TreeMap<>();
    for (final Field field : Loggers.class.getDeclaredFields()) {
        if (Modifier.isStatic(field.getModifiers()) && field.getType() == String.class) try {
            levels.put((String) field.get(null), null);
        } catch (IllegalAccessException e) {
            /*
             * Should never happen, unless we added some fields and forgot to update this method.
             * In such case forget the problematic fields and search the next one. This is okay
             * since this method is only for information purpose.
             */
            Logging.unexpectedException(Logging.getLogger(SYSTEM), Loggers.class, "getEffectiveLevels", e);
        }
    }
    /*
     * Process the loggers in alphabetical order. The intent is to process parent loggers before child.
     * The first logger in the map should be the SIS root logger, "org.apache.sis".
     */
    final Iterator<Map.Entry<String,Level>> it = levels.entrySet().iterator();
    while (it.hasNext()) {
        final Map.Entry<String,Level> entry = it.next();
        final String name = entry.getKey();
        final Logger logger = Logging.getLogger(name);
        Level level = getEffectiveLevel(logger);
        final Level h = getHandlerLevel(logger);
        if (h.intValue() > level.intValue()) {
            level = h;                              // Take in account the logging level of handlers.
        }
        entry.setValue(level);
        /*
         * Now verify if the level is identical to the effective level of parent logger.
         * If they are identical, then we remove the entry in order to report only the changes.
         */
        Logger parent = logger;
        while ((parent = parent.getParent()) != null) {
            final Level p = levels.get(parent.getName());
            if (p != null) {
                if (p.equals(level)) {
                    it.remove();
                }
                break;
            }
        }
    }
    return levels;
}
 

/** If package contains only one resource it is not too frendly to our classloaders.
     * Generally not a big problem OTOH we want to avoid this if this is simple.
     */
    public void testOneInPackage() throws Exception {
        SortedSet<Violation> violations = new TreeSet<Violation>();
        for (File f: org.netbeans.core.startup.Main.getModuleSystem().getModuleJars()) {
            // check JAR files only
            if (!f.getName().endsWith(".jar"))
                continue;
            
            // ignore branding
            if (f.getName().endsWith("_nb.jar"))
                continue;
            
            // a lot of alarms for 3rd party JARs
            if (f.getName().contains("modules/ext/"))
                continue;
            
            SortedMap<String, Integer> resourcesPerPackage = new TreeMap<String, Integer>();
            JarFile jar = new JarFile(f);
            Enumeration<JarEntry> entries = jar.entries();
            JarEntry entry;
            int entryCount = 0;
            while (entries.hasMoreElements()) {
                entry = entries.nextElement();
                if (entry.isDirectory())
                    continue;
                
                String name = entry.getName();
                String prefix = (name.lastIndexOf('/') >= 0)?
                    name.substring(0, name.lastIndexOf('/')): "";
                if (prefix.startsWith("META-INF")
                || prefix.startsWith("1.0/")
                || prefix.startsWith("com/")
                || prefix.startsWith("javax/")
                || prefix.startsWith("freemarker/")
                || prefix.startsWith("org/apache/tomcat")
                || prefix.startsWith("org/apache/lucene")
                || prefix.startsWith("org/w3c/")
//                || prefix.startsWith("")
                || prefix.startsWith("org/netbeans/modules/openide/actions")
                || prefix.startsWith("org/netbeans/modules/openide/awt")
                || prefix.startsWith("org/netbeans/modules/openide/windows")
                || prefix.startsWith("org/openide/explorer/propertysheet") // in deprecated core/settings
                || prefix.startsWith("org/openide/io")
                || prefix.startsWith("org/netbeans/api")
                || prefix.startsWith("org/netbeans/spi")
                || prefix.startsWith("org/netbeans/core/execution/beaninfo")
                || prefix.startsWith("org/netbeans/modules/web/monitor")
                || prefix.matches("org/netbeans/.*/[as]pi.*")
                        ) {
                    continue;
                }
                
                entryCount++;
                Integer count = resourcesPerPackage.get(prefix);
                if (count != null) {
                    resourcesPerPackage.put(prefix, count+1);
                }
                else {
                    resourcesPerPackage.put(prefix, 1);
                }
            }
            if (entryCount > 1) { // filter library wrappes (they have only Bundle.properties)
                for (Map.Entry<String, Integer> pkgInfo: resourcesPerPackage.entrySet()) {
                    if (pkgInfo.getValue().equals(1)) {
                        violations.add(new Violation(pkgInfo.getKey(), jar.getName(), " has package with just one resource"));
                    }
                }
            }
        }
        if (!violations.isEmpty()) {
            StringBuilder msg = new StringBuilder();
            msg.append("Some JARs in IDE contains sparsely populated packages ("+violations.size()+"):\n");
            for (Violation viol: violations) {
                msg.append(viol).append('\n');
            }
            fail(msg.toString());
        }
        //                    assertTrue (entry.toString()+" should have line number table", v.foundLineNumberTable());
    }
 

private static void hideAttributes(SortedMap<String, ?> map) {
    if (map.isEmpty())
        return;

    final SortedSet<String> hiddenStrings;
    final SortedSet<String> hiddenPrefixes;

    String hide = (String) map.get(HIDDEN_ATTRIBUTES);
    if (hide != null) {
        if (hide.startsWith("="))
            hide = hide.substring(1);
        else
            hide += " " + DEFAULT_HIDDEN_ATTRIBUTES;
        hiddenStrings = new TreeSet<String>();
        hiddenPrefixes = new TreeSet<String>();
        parseHiddenAttributes(hide, hiddenStrings, hiddenPrefixes);
    } else {
        hide = DEFAULT_HIDDEN_ATTRIBUTES;
        synchronized (defaultHiddenStrings) {
            if (defaultHiddenStrings.isEmpty()) {
                parseHiddenAttributes(hide,
                                      defaultHiddenStrings,
                                      defaultHiddenPrefixes);
            }
            hiddenStrings = defaultHiddenStrings;
            hiddenPrefixes = defaultHiddenPrefixes;
        }
    }

    /* Construct a string that is greater than any key in the map.
       Setting a string-to-match or a prefix-to-match to this string
       guarantees that we will never call next() on the corresponding
       iterator.  */
    String sentinelKey = map.lastKey() + "X";
    Iterator<String> keyIterator = map.keySet().iterator();
    Iterator<String> stringIterator = hiddenStrings.iterator();
    Iterator<String> prefixIterator = hiddenPrefixes.iterator();

    String nextString;
    if (stringIterator.hasNext())
        nextString = stringIterator.next();
    else
        nextString = sentinelKey;
    String nextPrefix;
    if (prefixIterator.hasNext())
        nextPrefix = prefixIterator.next();
    else
        nextPrefix = sentinelKey;

    /* Read each key in sorted order and, if it matches a string
       or prefix, remove it. */
keys:
    while (keyIterator.hasNext()) {
        String key = keyIterator.next();

        /* Continue through string-match values until we find one
           that is either greater than the current key, or equal
           to it.  In the latter case, remove the key.  */
        int cmp = +1;
        while ((cmp = nextString.compareTo(key)) < 0) {
            if (stringIterator.hasNext())
                nextString = stringIterator.next();
            else
                nextString = sentinelKey;
        }
        if (cmp == 0) {
            keyIterator.remove();
            continue keys;
        }

        /* Continue through the prefix values until we find one
           that is either greater than the current key, or a
           prefix of it.  In the latter case, remove the key.  */
        while (nextPrefix.compareTo(key) <= 0) {
            if (key.startsWith(nextPrefix)) {
                keyIterator.remove();
                continue keys;
            }
            if (prefixIterator.hasNext())
                nextPrefix = prefixIterator.next();
            else
                nextPrefix = sentinelKey;
        }
    }
}
 

private static void hideAttributes(SortedMap<String, ?> map) {
    if (map.isEmpty())
        return;

    final SortedSet<String> hiddenStrings;
    final SortedSet<String> hiddenPrefixes;

    String hide = (String) map.get(HIDDEN_ATTRIBUTES);
    if (hide != null) {
        if (hide.startsWith("="))
            hide = hide.substring(1);
        else
            hide += " " + DEFAULT_HIDDEN_ATTRIBUTES;
        hiddenStrings = new TreeSet<String>();
        hiddenPrefixes = new TreeSet<String>();
        parseHiddenAttributes(hide, hiddenStrings, hiddenPrefixes);
    } else {
        hide = DEFAULT_HIDDEN_ATTRIBUTES;
        synchronized (defaultHiddenStrings) {
            if (defaultHiddenStrings.isEmpty()) {
                parseHiddenAttributes(hide,
                                      defaultHiddenStrings,
                                      defaultHiddenPrefixes);
            }
            hiddenStrings = defaultHiddenStrings;
            hiddenPrefixes = defaultHiddenPrefixes;
        }
    }

    /* Construct a string that is greater than any key in the map.
       Setting a string-to-match or a prefix-to-match to this string
       guarantees that we will never call next() on the corresponding
       iterator.  */
    String sentinelKey = map.lastKey() + "X";
    Iterator<String> keyIterator = map.keySet().iterator();
    Iterator<String> stringIterator = hiddenStrings.iterator();
    Iterator<String> prefixIterator = hiddenPrefixes.iterator();

    String nextString;
    if (stringIterator.hasNext())
        nextString = stringIterator.next();
    else
        nextString = sentinelKey;
    String nextPrefix;
    if (prefixIterator.hasNext())
        nextPrefix = prefixIterator.next();
    else
        nextPrefix = sentinelKey;

    /* Read each key in sorted order and, if it matches a string
       or prefix, remove it. */
keys:
    while (keyIterator.hasNext()) {
        String key = keyIterator.next();

        /* Continue through string-match values until we find one
           that is either greater than the current key, or equal
           to it.  In the latter case, remove the key.  */
        int cmp = +1;
        while ((cmp = nextString.compareTo(key)) < 0) {
            if (stringIterator.hasNext())
                nextString = stringIterator.next();
            else
                nextString = sentinelKey;
        }
        if (cmp == 0) {
            keyIterator.remove();
            continue keys;
        }

        /* Continue through the prefix values until we find one
           that is either greater than the current key, or a
           prefix of it.  In the latter case, remove the key.  */
        while (nextPrefix.compareTo(key) <= 0) {
            if (key.startsWith(nextPrefix)) {
                keyIterator.remove();
                continue keys;
            }
            if (prefixIterator.hasNext())
                nextPrefix = prefixIterator.next();
            else
                nextPrefix = sentinelKey;
        }
    }
}
 

/**
 * createNatureSelector
 * 
 * @param parent
 */
protected void createNatureSelector(Composite parent)
{
	// grab nature label+id list
	SortedMap<String, String> natureMap = getNatureMap();

	// combo label
	Label label = new Label(parent, SWT.LEFT);
	label.setFont(parent.getFont());
	label.setText(Messages.ContentAssistPreferencePage_NatureComboLabel);

	// create combo
	natureCombo = new Combo(parent, SWT.READ_ONLY);
	natureCombo.setFont(parent.getFont());

	GridData gd = new GridData();
	gd.horizontalSpan = 1;
	gd.horizontalAlignment = GridData.FILL;
	natureCombo.setLayoutData(gd);

	// Selected nature, in case it's a property page.
	boolean isProjectPreference = isProjectPreferencePage();
	String primaryProjectNature = null;
	if (isProjectPreference)
	{
		try
		{
			String[] aptanaNatures = ResourceUtil.getAptanaNatures(getProject().getDescription());
			if (!ArrayUtil.isEmpty(aptanaNatures))
			{
				primaryProjectNature = aptanaNatures[0];
			}
		}
		catch (CoreException e)
		{
		}
	}
	// set combo list
	for (Map.Entry<String, String> entry : natureMap.entrySet())
	{
		if (primaryProjectNature != null)
		{
			// Select only the matching entry
			if (primaryProjectNature.equals(entry.getValue()))
			{
				natureCombo.add(entry.getKey());
				break;
			}
		}
		else
		{
			natureCombo.add(entry.getKey());
		}
	}

	// select first item and save reference to that nature id for future selection updates
	natureCombo.select(0);
	activeNatureID = natureMap.get(natureCombo.getText());

	natureCombo.setEnabled(!isProjectPreference);
	if (!isProjectPreference)
	{
		natureCombo.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent evt)
			{
				// update selection in model
				userAgentsByNatureID.put(activeNatureID, getSelectedUserAgents());

				// update nature id
				activeNatureID = getNatureMap().get(natureCombo.getText());

				// update visible selection
				updateUserAgentSelection();
			}
		});
	}
}
 

protected void mergeAndSetRowLevels(XlsRowLevelInfo levelInfo, SortedMap<String, Boolean> rowLevelMap, int rowIndex)
	{
		if (rowLevelMap != null)
		{
			SortedMap<String, Integer> crtLevelMap = levelInfo.getLevelMap();

			for (String level : rowLevelMap.keySet())
			{
				Boolean isEndMarker = rowLevelMap.get(level);
				
				//check if this level group is already open
				if (crtLevelMap.containsKey(level))
				{
					//the level group is already open
					
					if (isEndMarker)
					{
						//the level group needs to be closed, together with all its child level groups
						setRowLevels(levelInfo, level);

						//clean up current level group and nested level groups as they were closed 
						for (Iterator<String> it = crtLevelMap.keySet().iterator(); it.hasNext();)
						{
							if (level.compareTo(it.next()) <= 0)
							{
								it.remove();
							}
						}
					}
				}
				else // if (!isEndMarker)  // FIXMEXLS we should not add level if it is an end marker
				{
					//the level group is not yet open

					//we check to see if this level is higher than existing levels
					if (crtLevelMap.size() > 0 && level.compareTo(crtLevelMap.firstKey()) < 0)
					{
						//the level is higher than existing levels, so it has to close them all
						setRowLevels(levelInfo, level);
						
						//clean up nested level groups as they were closed; the current one is not yet among them 
						for (Iterator<String> it = crtLevelMap.keySet().iterator(); it.hasNext();)
						{
							if (level.compareTo(it.next()) < 0)
							{
								it.remove();
							}
						}
					}
					
					//create the current level group
//					XlsRowLevelRange range = new XlsRowLevelRange();
//					range.setStartIndex(rowIndex);
					//range.setEndIndex(rowIndex);
					//range.setName(groupName);
					crtLevelMap.put(level, rowIndex);
				}
			}
		}

		levelInfo.setEndIndex(rowIndex);
	}
 

private void addToMap(BigInteger N, int exp, SortedMap<BigInteger, Integer> map) {
	Integer oldExp = map.get(N);
	// old entry is replaced if oldExp!=null
	map.put(N, (oldExp == null) ? exp : oldExp+exp);
}