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

private void populateRows(final List<Job<?, ?>> visibleJobs, final SortedMap<String, String> toolNamesById) {
    for (Job<?, ?> job : visibleJobs) {
        TableRow row = new TableRow(job);
        for (String id : toolNamesById.keySet()) {
            Run<?, ?> lastCompletedBuild = job.getLastCompletedBuild();
            if (lastCompletedBuild == null) {
                row.add(Result.EMPTY);
            }
            else {
                Result result = lastCompletedBuild.getActions(ResultAction.class)
                        .stream()
                        .filter(action -> action.getId().equals(id))
                        .findFirst()
                        .map(Result::new)
                        .orElse(Result.EMPTY);
                row.add(result);
            }
        }
        rows.add(row);
    }
}
 

public static JSONArray sortJsonByKey(JSONArray json, String key)
{
    JSONArray sorted = new JSONArray();
    SortedMap map = new TreeMap();

    for (Object o : json) {
        JSONObject tmp = (JSONObject) o;
        map.put(tmp.get(key),tmp);
    }

    Set<String> numbers = map.keySet();

    for (String number : numbers) {
        sorted.add(map.get(number));
    }

    return sorted;
}
 

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);
        }
    }
}
 

@Override
public void responseAnnotations(SortedMap<String, byte[]> annotations, int msgtype)
{
	System.out.println("    Got response (type=" + msgtype + "). Annotations:");
	for(String ann: annotations.keySet()) {
		String value;
		if(ann.equals("CORR")) {
			ByteBuffer bb = ByteBuffer.wrap(annotations.get(ann));
			value = new UUID(bb.getLong(), bb.getLong()).toString();
		} else if (ann.equals("HMAC")) {
			value = "[...]";
		} else {
			value = annotations.get(ann).toString();
		}
		System.out.println("      " + ann + " -> " + value);
	}
	
}
 

@Test
public void testGenerateBEDFromVCF() {
  String file = GenomeWarpSerialTest.class.getClassLoader().getResource(VCF_PATH).getFile();
  VCFFileReader testVcf = new VCFFileReader(new File(file), false);

  SortedMap<String, List<GenomeRange>> want = new TreeMap<String, List<GenomeRange>>() {{
    put("chr1", new ArrayList<GenomeRange>() {{
      add(new GenomeRange("chr1", 49, 50));
      add(new GenomeRange("chr1", 51, 52));
      add(new GenomeRange("chr1", 119, 122));
      add(new GenomeRange("chr1", 136, 137));
      add(new GenomeRange("chr1", 189, 190));
    }});
    put("chr2", new ArrayList<GenomeRange>() {{
      add(new GenomeRange("chr2", 139, 141));
    }});
  }};

  SortedMap<String, List<GenomeRange>> got = GenomeRangeUtils.generateBEDFromVCF(testVcf, null);
  assertEquals(got.size(), want.size());
  for(String key: got.keySet()) {
    assertTrue(GenomeWarpTestUtils.equivalentRanges(got.get(key), want.get(key)));
  }
}
 

/**
 * Saves the metrics to a file for it to be reloaded when the crawler restarts
 * 
 * @param metricsRegistry
 * @param directoryPath
 * @throws IOException
 */
private void saveMetrics(MetricRegistry metricsRegistry, String directoryPath) {
    String directoryName = directoryPath + "/metrics/";
    File file = new File(directoryName);
    if (file.exists()) {
        file.delete();
    }
    file.mkdir();
    try {
        File outputFile = new File(directoryName + "metrics_counters.data");
        BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile));
        SortedMap<String, Counter> counters = metrics.getCounters();
        for (String counter : counters.keySet()) {
            Counter c = counters.get(counter);
            writer.write(counter + ":" + c.getCount());
            writer.newLine();
            writer.flush();
        }
        writer.flush();
        writer.close();
    } catch (IOException e) {
        logger.error("Unable to save metrics to a file." + e.getMessage());
    }
}
 

public String toString() {
  StringBuffer buf = new StringBuffer();
  SortedMap<String,Object> map = this.toSortedMap();
  for (String key : map.keySet()) {
    Object val = map.get(key);
    buf.append(key + "=" + val + "\n");
  }
  return buf.toString();
}
 

private void putAttrsIntoInputStream(List<Object> input, String streamName, SortedMap map) {
	if(!needValidation) {
		input.addAll(map.values());
		return;
	}
	for (Object key : map.keySet()) {
		Object value = map.get(key);
		if (value == null) {
			input.add(SiddhiStreamMetadataUtils.getAttrDefaultValue(streamName, (String)key));
		}
		else input.add(value);
	}
}
 

public BitSet getDuplicates(int pos) {
    if (duplicateBlocks == null) {
        return new BitSet();
    }
    BitSet current = new BitSet();
    current.set(pos);
    boolean changed;
    do {
        changed = false;
        for (SortedMap<Integer, Integer> duplicates : duplicateBlocks) {
            for (int i = current.nextSetBit(0); i >= 0; i = current.nextSetBit(i + 1)) {
                int offset = getOffset(duplicates, i);
                if (offset >= 0) {
                    for (Integer key : duplicates.keySet()) {
                        int dupPosition = positions[getInstructionNumber(positions, key) + offset];
                        if (!current.get(dupPosition)) {
                            changed = true;
                            current.set(dupPosition);
                        }
                    }
                }
            }
        }
    } while (changed && duplicateBlocks.size() > 1);
    current.clear(pos);
    return current;
}
 

/**
 * Return the token index for the given position.
 *
 * @param sourceCode
 * @return
 */
protected static SortedMap<Integer, Integer> getTokenIndexForPostion(
		final SortedMap<Integer, String> tokenPositions) {
	final SortedMap<Integer, Integer> positionToIndex = Maps.newTreeMap();
	int i = 0;
	for (final int position : tokenPositions.keySet()) {
		positionToIndex.put(position, i);
		i++;
	}
	return positionToIndex;
}
 

@Test
public void testNewControl() {
    SortedMap<String, Charset> charsetsSortedMap = Charset.availableCharsets();
    for (String encoding : charsetsSortedMap.keySet()) {
        ResourceBundle.Control control = PropertyResourceBundleControl.newControl(encoding);
        Assert.assertNotNull(control);
    }
}
 

/**
 * Returns Key if value is found in SortedMap, including also simple wildcard *
 */
public static <V> String simpleWildcardKeyFind(SortedMap<String,V> baseMap, String value) {
    if (value == null) {
        return null;
    }
    
    if (baseMap.get(value) != null) {
        //System.out.println("======= " + value);
        return value;
    } else if (value.length() > 0){
        String v = value;
        v = v.substring(0, v.length() - 1);
            
        while (v.length() > 0) {
            char nextLetter = (char)(v.charAt(v.length() -1) + 1);
            String end = v.substring(0, v.length()-1) + nextLetter;
            SortedMap<String, V> b = baseMap.subMap(v, end);
            
            for (String key : b.keySet()) {
                if ((key.length() == v.length() + 1) && key.endsWith("*")) {
                    //System.out.println("======= " + key);
                    return key;
                }
            }
            
            v = v.substring(0, v.length() - 1);
        }        
    }   
    return null;
}
 

/**
 * Outputs the file.
 */
private static void outputFile(File dstFile, String version, SortedMap<String, ZoneRules> builtZones, SortedMap<LocalDate, Byte> leapSeconds) {
    Map<String, SortedMap<String, ZoneRules>> loopAllBuiltZones = new TreeMap<String, SortedMap<String, ZoneRules>>();
    loopAllBuiltZones.put(version, builtZones);
    Set<String> loopAllRegionIds = new TreeSet<String>(builtZones.keySet());
    Set<ZoneRules> loopAllRules = new HashSet<ZoneRules>(builtZones.values());
    outputFile(dstFile, loopAllBuiltZones, loopAllRegionIds, loopAllRules, leapSeconds);
}
 

private final NavigableSet<FilesystemBulkImportItemVersion> constructImportItemVersions(final SortedMap<BigDecimal,Pair<File,File>> itemVersions)
    throws InterruptedException
{
    // PRECONDITIONS
    if (itemVersions        == null) throw new IllegalArgumentException("itemVersions cannot be null.");
    if (itemVersions.size() <= 0)    throw new IllegalArgumentException("itemVersions cannot be empty.");
    
    // Body
    final NavigableSet<FilesystemBulkImportItemVersion> result = new TreeSet<>();
    
    for (final BigDecimal versionNumber : itemVersions.keySet())
    {
        if (importStatus.isStopping() || Thread.currentThread().isInterrupted()) throw new InterruptedException(Thread.currentThread().getName() + " was interrupted. Terminating early.");
        
        final Pair<File,File>   contentAndMetadataFiles = itemVersions.get(versionNumber);
        final FilesystemBulkImportItemVersion version   = new FilesystemBulkImportItemVersion(serviceRegistry,
                                                                                              configuredContentStore,
                                                                                              metadataLoader,
                                                                                              versionNumber,
                                                                                              contentAndMetadataFiles.getFirst(),
                                                                                              contentAndMetadataFiles.getSecond());
        
        result.add(version);
    }
    
    return(result);
}
 

void assertSortedMapCharacteristics(SortedMap<Integer, String> m, int keyCharacteristics) {
    assertMapCharacteristics(m, keyCharacteristics, Spliterator.SORTED);

    Set<Integer> keys = m.keySet();
    if (m.comparator() != null) {
        assertNotNullComparator(keys);
    }
    else {
        assertNullComparator(keys);
    }

    assertISEComparator(m.values());

    assertNotNullComparator(m.entrySet());
}
 

public static Data makeYamlHDF(SortedMap<String, Object> sorted, String base, Data data) {
  
  String key = "docs.pages.";
  int i = 0;
  for (String s : sorted.keySet()) {
    Object o = sorted.get(s);   
    
    if (o instanceof PackageInfo) {
      PackageInfo pkg = (PackageInfo) o;
      
      data.setValue("docs.pages." + i + ".id", "" + i);
      data.setValue("docs.pages." + i + ".label", pkg.name());
      data.setValue("docs.pages." + i + ".shortname", "API");
      data.setValue("docs.pages." + i + ".link", pkg.htmlPage());
      data.setValue("docs.pages." + i + ".type", "package");
    } else if (o instanceof ClassInfo) {
      ClassInfo cl = (ClassInfo) o;
      
      // skip classes that are the child of another class, recursion will handle those.
      if (cl.containingClass() == null){
        
        data.setValue("docs.pages." + i + ".id", "" + i);

        data = makeYamlHDF(cl, "docs.pages."+i, data);
      }
    }
    
    i++;
  }
  return data;
}
 

/**
 * Find the highest revision for the given scriptModuleId
 * @param scriptModuleId name to search for
 * @return the highest revision number or -1 if no revisions exist
 */
public long getLatestRevisionNumber(ModuleId scriptModuleId) {
    Objects.requireNonNull(scriptModuleId, "scriptModuleId");
    ModuleIdentifier searchIdentifier = JBossModuleUtils.createRevisionId(scriptModuleId, 0);
    SortedMap<ModuleIdentifier,ModuleSpec> tailMap = moduleSpecs.tailMap(searchIdentifier);
    long revisionNumber = -1;
    for (ModuleIdentifier revisionId : tailMap.keySet()) {
        if (revisionId.getName().equals(scriptModuleId.toString())) {
            revisionNumber = getRevisionNumber(revisionId);
        } else {
            break;
        }
    }
    return revisionNumber;
}
 

public JSONArray getDataToSend(List<SampleResult> list) {
    JSONArray data = new JSONArray();

    SortedMap<Long, List<SampleResult>> sortedResults = sortResults(list);
    for (Long sec : sortedResults.keySet()) {
        data.add(getAggregateSecond(sec, sortedResults.get(sec)));
    }
    return data;
}
 

private CompositeDataSupport(
        SortedMap<String, Object> items, CompositeType compositeType)
        throws OpenDataException {

    // Check compositeType is not null
    //
    if (compositeType == null) {
        throw new IllegalArgumentException("Argument compositeType cannot be null.");
    }

    // item names defined in compositeType:
    Set<String> namesFromType = compositeType.keySet();
    Set<String> namesFromItems = items.keySet();

    // This is just a comparison, but we do it this way for a better
    // exception message.
    if (!namesFromType.equals(namesFromItems)) {
        Set<String> extraFromType = new TreeSet<String>(namesFromType);
        extraFromType.removeAll(namesFromItems);
        Set<String> extraFromItems = new TreeSet<String>(namesFromItems);
        extraFromItems.removeAll(namesFromType);
        if (!extraFromType.isEmpty() || !extraFromItems.isEmpty()) {
            throw new OpenDataException(
                    "Item names do not match CompositeType: " +
                    "names in items but not in CompositeType: " + extraFromItems +
                    "; names in CompositeType but not in items: " + extraFromType);
        }
    }

    // Check each value, if not null, is of the open type defined for the
    // corresponding item
    for (String name : namesFromType) {
        Object value = items.get(name);
        if (value != null) {
            OpenType<?> itemType = compositeType.getType(name);
            if (!itemType.isValue(value)) {
                throw new OpenDataException(
                        "Argument value of wrong type for item " + name +
                        ": value " + value + ", type " + itemType);
            }
        }
    }

    // Initialize internal fields: compositeType and contents
    //
    this.compositeType = compositeType;
    this.contents = items;
}
 

private CompositeDataSupport(
        SortedMap<String, Object> items, CompositeType compositeType)
        throws OpenDataException {

    // Check compositeType is not null
    //
    if (compositeType == null) {
        throw new IllegalArgumentException("Argument compositeType cannot be null.");
    }

    // item names defined in compositeType:
    Set<String> namesFromType = compositeType.keySet();
    Set<String> namesFromItems = items.keySet();

    // This is just a comparison, but we do it this way for a better
    // exception message.
    if (!namesFromType.equals(namesFromItems)) {
        Set<String> extraFromType = new TreeSet<String>(namesFromType);
        extraFromType.removeAll(namesFromItems);
        Set<String> extraFromItems = new TreeSet<String>(namesFromItems);
        extraFromItems.removeAll(namesFromType);
        if (!extraFromType.isEmpty() || !extraFromItems.isEmpty()) {
            throw new OpenDataException(
                    "Item names do not match CompositeType: " +
                    "names in items but not in CompositeType: " + extraFromItems +
                    "; names in CompositeType but not in items: " + extraFromType);
        }
    }

    // Check each value, if not null, is of the open type defined for the
    // corresponding item
    for (String name : namesFromType) {
        Object value = items.get(name);
        if (value != null) {
            OpenType<?> itemType = compositeType.getType(name);
            if (!itemType.isValue(value)) {
                throw new OpenDataException(
                        "Argument value of wrong type for item " + name +
                        ": value " + value + ", type " + itemType);
            }
        }
    }

    // Initialize internal fields: compositeType and contents
    //
    this.compositeType = compositeType;
    this.contents = items;
}