下面列出了怎么用java.util.SortedMap的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public long calculateCompactionIndex(SortedMap<Long, Long> snapshotTimestamps, Journal journal) {
long index = -1;
long now = System.currentTimeMillis();
if (retentionMin > 0) {
long compactTimestamp = now - retentionMin * 60 * 1000L;
for (Map.Entry<Long, Long> entry : snapshotTimestamps.entrySet()) {
long snapshotIndex = entry.getKey();
long snapshotTimestamp = entry.getValue();
if (snapshotTimestamp <= compactTimestamp) {
index = snapshotIndex;
} else {
break;
}
}
logger.info("Calculate journal compaction index: {}, current timestamp: {}.", index, ThreadSafeFormat.format(new Date(now)));
}
return index;
}
private Map createMap()
throws IOException
{
if (_type == null)
return new HashMap();
else if (_type.equals(Map.class))
return new HashMap();
else if (_type.equals(SortedMap.class))
return new TreeMap();
else {
try {
return (Map) _ctor.newInstance();
} catch (Exception e) {
throw new IOExceptionWrapper(e);
}
}
}
public static SortedMap<String, Boolean> computeExportList (Map<Integer, String> exportInstructions, Project project) {
SortedMap<String, Boolean> pkgMap = new TreeMap<String, Boolean>();
SortedSet<String> pkgNames = FileUtilities.getPackageNames(project);
for (String name : pkgNames) {
pkgMap.put(name, Boolean.FALSE);
}
String exportIns = exportInstructions.get(EXPORT_PACKAGE);
if (exportIns != null) {
StringTokenizer strTok = new StringTokenizer(exportIns, DELIMITER);
while(strTok.hasMoreTokens()) {
String cur = strTok.nextToken();
pkgMap.remove(cur);
pkgMap.put(cur, Boolean.TRUE);
}
}
return pkgMap;
}
/**
* Convenient method to connect parts across pages.
* This method is to be used when merging the results of several pages.
* Here we work directly with Audiveris Page entities
*
* @param pages the sequence of pages, as (audiveris) Page instances
*/
public static PartConnection connectScorePages (
SortedMap<Integer, Page> pages)
{
// Build candidates (here a candidate is a ScorePart)
Set<List<Candidate>> sequences = new LinkedHashSet<>();
for (Entry<Integer, Page> entry : pages.entrySet()) {
Page page = entry.getValue();
List<ScorePart> partList = page.getPartList();
List<Candidate> parts = new ArrayList<>();
for (ScorePart scorePart : partList) {
parts.add(new ScorePartCandidate(scorePart, page));
}
sequences.add(parts);
}
return new PartConnection(sequences);
}
private SortedMap<IClass, List<ITestResult>> sortByTestClass(IResultMap results) {
SortedMap<IClass, List<ITestResult>> sortedResults = new TreeMap<IClass, List<ITestResult>>(CLASS_COMPARATOR);
for (ITestResult result : results.getAllResults()) {
List<ITestResult> resultsForClass = sortedResults.get(result.getTestClass());
if (resultsForClass == null) {
resultsForClass = new ArrayList<>();
sortedResults.put(result.getTestClass(), resultsForClass);
}
int index = Collections.binarySearch(resultsForClass, result, RESULT_COMPARATOR);
if (index < 0) {
index = Math.abs(index + 1);
}
resultsForClass.add(index, result);
}
return sortedResults;
}
private List<RecordField> getRecordFields() {
if (this.recordFields != null) {
return this.recordFields;
}
// Use a SortedMap keyed by index of the field so that we can get a List of field names in the correct order
final SortedMap<Integer, String> sortedMap = new TreeMap<>();
for (final Map.Entry<String, Integer> entry : csvParser.getHeaderMap().entrySet()) {
sortedMap.put(entry.getValue(), entry.getKey());
}
final List<RecordField> fields = new ArrayList<>();
final List<String> rawFieldNames = new ArrayList<>(sortedMap.values());
for (final String rawFieldName : rawFieldNames) {
final Optional<RecordField> option = schema.getField(rawFieldName);
if (option.isPresent()) {
fields.add(option.get());
} else {
fields.add(new RecordField(rawFieldName, RecordFieldType.STRING.getDataType()));
}
}
this.recordFields = fields;
return fields;
}
/**
* Returns a sorted list of all transformers sorted by name.
* @param transformerName to restrict the collection to one entry
* @return a new Collection of sorted transformers
* @throws IllegalArgumentException if transformerName is not found.
* @deprecated The transformations code is being moved out of the codebase and replaced by the new async RenditionService2 or other external libraries.
*/
@Deprecated
public Collection<ContentTransformer> sortTransformersByName(String transformerName)
{
Collection<ContentTransformer> transformers = (transformerName != null)
? Collections.singleton(transformerRegistry.getTransformer(transformerName))
: transformerRegistry.getAllTransformers();
SortedMap<String, ContentTransformer> map = new TreeMap<String, ContentTransformer>();
for (ContentTransformer transformer: transformers)
{
String name = transformer.getName();
map.put(name, transformer);
}
Collection<ContentTransformer> sorted = map.values();
return sorted;
}
/**
* construct a full wire message including data and annotations payloads.
*/
public Message(int msgType, byte[] databytes, int serializer_id, int flags, int seq, SortedMap<String, byte[]> annotations, byte[] hmac)
{
this(msgType, serializer_id, flags, seq);
this.data = databytes;
this.data_size = databytes.length;
this.annotations = annotations;
if(null==annotations)
this.annotations = new TreeMap<String, byte[]>();
if(hmac!=null)
this.annotations.put("HMAC", this.hmac(hmac)); // do this last because it hmacs the other annotation chunks
this.annotations_size = 0;
for(Entry<String, byte[]> a: this.annotations.entrySet())
this.annotations_size += a.getValue().length+6;
}
@Test
public void testNoAdvertiseInactive() throws IOException {
Batfish batfish =
BatfishTestUtils.getBatfishFromTestrigText(
TestrigText.builder()
.setConfigurationFiles(
SNAPSHOT_PATH, AS1_NAME, AS2_NO_ADVERTISE_INACTIVE_NAME, AS3_NAME)
.build(),
_folder);
batfish.computeDataPlane(batfish.getSnapshot());
IncrementalDataPlane dataplane =
(IncrementalDataPlane) batfish.loadDataPlane(batfish.getSnapshot());
SortedMap<String, SortedMap<String, Set<AbstractRoute>>> routes =
IncrementalBdpEngine.getRoutes(dataplane);
assertRoute(routes, RoutingProtocol.STATIC, AS1_NAME, Prefix.ZERO, 0, STATIC_NEXT_HOP);
assertRoute(
routes,
RoutingProtocol.STATIC,
AS2_NO_ADVERTISE_INACTIVE_NAME,
Prefix.ZERO,
0,
STATIC_NEXT_HOP);
assertNoRoute(routes, AS3_NAME, Prefix.ZERO);
}
private static String toID(SortedMap<Character, Extension> map) {
StringBuilder buf = new StringBuilder();
Extension privuse = null;
for (Entry<Character, Extension> entry : map.entrySet()) {
char singleton = entry.getKey();
Extension extension = entry.getValue();
if (LanguageTag.isPrivateusePrefixChar(singleton)) {
privuse = extension;
} else {
if (buf.length() > 0) {
buf.append(LanguageTag.SEP);
}
buf.append(extension);
}
}
if (privuse != null) {
if (buf.length() > 0) {
buf.append(LanguageTag.SEP);
}
buf.append(privuse);
}
return buf.toString();
}
/** Run BIDE algorithm */
public static SortedMap<Sequence, Integer> mineFrequentClosedSequencesBIDE(final String dataset,
final String saveFile, final double minSupp) throws IOException {
final SequenceDatabase sequenceDatabase = new SequenceDatabase();
sequenceDatabase.loadFile(dataset);
// Convert to absolute support (rounding down)
final int absMinSupp = (int) (sequenceDatabase.size() * minSupp);
final AlgoBIDEPlus algo = new AlgoBIDEPlus();
algo.setShowSequenceIdentifiers(false);
final SequentialPatterns patterns = algo.runAlgorithm(sequenceDatabase, saveFile, absMinSupp);
// algo.printStatistics(sequenceDatabase.size());
return toMap(patterns);
}
/**
* headMap returns map with keys in requested range
*/
public void testHeadMapContents() {
ConcurrentNavigableMap map = map5();
SortedMap sm = map.headMap(four);
assertTrue(sm.containsKey(one));
assertTrue(sm.containsKey(two));
assertTrue(sm.containsKey(three));
assertFalse(sm.containsKey(four));
assertFalse(sm.containsKey(five));
Iterator i = sm.keySet().iterator();
Object k;
k = (Integer)(i.next());
assertEquals(one, k);
k = (Integer)(i.next());
assertEquals(two, k);
k = (Integer)(i.next());
assertEquals(three, k);
assertFalse(i.hasNext());
sm.clear();
assertTrue(sm.isEmpty());
assertEquals(2, map.size());
assertEquals(four, map.firstKey());
}
/**
* headMap returns map with keys in requested range
*/
public void testDescendingHeadMapContents() {
NavigableMap map = dmap5();
SortedMap sm = map.headMap(m4);
assertTrue(sm.containsKey(m1));
assertTrue(sm.containsKey(m2));
assertTrue(sm.containsKey(m3));
assertFalse(sm.containsKey(m4));
assertFalse(sm.containsKey(m5));
Iterator i = sm.keySet().iterator();
Object k;
k = (Integer)(i.next());
assertEquals(m1, k);
k = (Integer)(i.next());
assertEquals(m2, k);
k = (Integer)(i.next());
assertEquals(m3, k);
assertFalse(i.hasNext());
sm.clear();
assertTrue(sm.isEmpty());
assertEquals(2, map.size());
assertEquals(m4, map.firstKey());
}
/** Convert frequent sequences to sorted Map<Sequence, Integer> */
public static SortedMap<Sequence, Integer> toMap(final SequentialPatterns patterns) {
if (patterns == null) {
return null;
} else {
final HashMap<Sequence, Integer> sequences = new HashMap<>();
for (final List<SequentialPattern> level : patterns.levels) {
for (final SequentialPattern pattern : level) {
final Sequence seq = new Sequence();
for (final Itemset set : pattern.getItemsets())
seq.add(set.get(0)); // Assumes a seq is just singleton
// itemsets
sequences.put(seq, pattern.getAbsoluteSupport());
}
}
// Sort patterns by support
final Ordering<Sequence> comparator = Ordering.natural().reverse().onResultOf(Functions.forMap(sequences))
.compound(Ordering.usingToString());
return ImmutableSortedMap.copyOf(sequences, comparator);
}
}
/**
* Sort parameters based on schema order (BFS)
* @param parameters Parameters to be sorted
* @return The parameters sorted alphabetically
*/
public Map<String, String> sortParameters(Map<String, String> parameters) {
NavigableMap<String, String> navigableParameters = new TreeMap<String, String>(parameters);
//extract parameter names in order
BalloonInputFieldsUtils collectParametersHandler = new BalloonInputFieldsUtils();
Map<String, String> sortedParameterNameByNodePath = collectParametersHandler.getHtmlParameterNameByNodePath(earthSurveyService.getRootEntityDefinition());
List<String> sortedParameterNames = new ArrayList<String>(sortedParameterNameByNodePath.values());
//create a new map and put the parameters in order there
Map<String, String> result = new LinkedHashMap<String, String>(navigableParameters.size());
for (String parameterName : sortedParameterNames) {
//get all the entries with key starting with parameterName
SortedMap<String,String> subMap = new TreeMap<String, String>( navigableParameters.subMap(parameterName, parameterName + Character.MAX_VALUE) );
Set<Entry<String,String>> entrySet = subMap.entrySet();
for (Entry<String, String> entry : entrySet) {
result.put(entry.getKey(), entry.getValue());
navigableParameters.remove(entry.getKey());
}
}
//add remaining parameters (if any)
result.putAll(navigableParameters);
return result;
}
private HRegion getBiggestMemStoreOfRegionReplica(
SortedMap<Long, Collection<HRegion>> regionsBySize,
Set<HRegion> excludedRegions) {
synchronized (regionsInQueue) {
for (Map.Entry<Long, Collection<HRegion>> entry : regionsBySize.entrySet()) {
for (HRegion region : entry.getValue()) {
if (excludedRegions.contains(region)) {
continue;
}
if (RegionReplicaUtil.isDefaultReplica(region.getRegionInfo())) {
continue;
}
return region;
}
}
}
return null;
}
@Test
public void testWithNoPolicy() throws IOException {
/*
Construct TCP flow to 9.9.9.9, but don't set up PBR. Flow should take V1's static route out i1.
*/
SortedMap<String, Configuration> configs = pbrNetwork(false);
Batfish batfish = BatfishTestUtils.getBatfish(configs, _folder);
batfish.computeDataPlane(batfish.getSnapshot());
PacketHeaderConstraints header =
PacketHeaderConstraints.builder()
.setSrcIp("1.1.1.222")
.setDstIp("9.9.9.9")
.setIpProtocols(ImmutableSet.of(IpProtocol.TCP))
.build();
TracerouteQuestion question =
new TracerouteQuestion(SOURCE_LOCATION_STR, header, false, DEFAULT_MAX_TRACES);
TracerouteAnswerer answerer = new TracerouteAnswerer(question, batfish);
Map<Flow, List<Trace>> traces = answerer.getTraces(batfish.getSnapshot(), question);
assertThat(traces.entrySet(), hasSize(1));
assertThat(
traces.values().iterator().next(),
contains(hasHop(hasOutputInterface(NodeInterfacePair.of("c1", "i1")))));
}
private SortedMap<Long, WALEdit> resolvePendingTransaction(final SortedMap<Long, WALEdit> pendingTransactionsById)
throws IOException {
SortedMap<Long, WALEdit> commitedTransactionsById = new TreeMap<Long, WALEdit>();
LOG.info("Region log has " + pendingTransactionsById.size()
+ " unfinished transactions. Going to the transaction log to resolve");
for (Entry<Long, WALEdit> entry : pendingTransactionsById.entrySet()) {
TransactionLogger.TransactionStatus transactionStatus;
transactionStatus = getGlobalTransactionLog().getStatusForTransaction(entry.getKey());
if (transactionStatus == null) {
throw new RuntimeException("Cannot resolve tranasction [" + entry.getKey() + "] from global tx log.");
}
switch (transactionStatus) {
case ABORTED:
break;
case COMMITTED:
commitedTransactionsById.put(entry.getKey(), entry.getValue());
break;
case PENDING:
LOG.warn("Transaction [" + entry.getKey() + "] is still pending. Asumming it will not commit.");
// FIXME / REVIEW validate this behavior/assumption
// Can safely ignore this because if we don't see a commit or abort in the regions WAL, the we must
// not have been
// asked to vote yet.
break;
}
}
return commitedTransactionsById;
}
/**
* Constructs a new tree map containing the same mappings and using the same ordering as the specified sorted map.
* This method runs in linear time.
*
* @param m the sorted map whose mappings are to be placed in this map, and whose comparator is to be used to sort
* this map
* @throws NullPointerException if the specified map is null
*/
public IndexedTreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException | ClassNotFoundException cannotHappen) {
// do nothing
}
}
public byte[] generateIndexRowkey(TaggedLogAPIEntity entity) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
if (entity.getClass() != entityDef.getEntityClass()) {
throw new IllegalArgumentException("Expected entity class: " + entityDef.getEntityClass().getName() + ", but got class " + entity.getClass().getName());
}
final byte[][] indexValues = generateIndexValues(entity);
final int[] partitionHashCodes = generatePartitionHashCodes(entity);
SortedMap<Integer, Integer> tagMap = null;
if (!index.unique()) {
// non cluster index
tagMap = RowkeyBuilder.generateSortedTagMap(entityDef.getPartitions(), entity.getTags());
}
return generateUniqueIndexRowkey(indexValues, partitionHashCodes, tagMap);
}
/**
* <p>Creates an instance based on user-defined data. </p>
*
* @param timeToLabels map containing the day-periods where the keys represent starting points
* and the values represent the associated labels intended for representation
* @return user-specific instance
* @throws IllegalArgumentException if given map is empty or contains empty values
* @since 3.13/4.10
*/
/*[deutsch]
* <p>Erzeugt eine Instanz, die auf benutzerdefinierten Daten beruht. </p>
*
* @param timeToLabels map containing the day-periods where the keys represent starting points
* and the values represent the associated labels intended for representation
* @return user-specific instance
* @throws IllegalArgumentException if given map is empty or contains empty values
* @since 3.13/4.10
*/
public static DayPeriod of(Map<PlainTime, String> timeToLabels) {
if (timeToLabels.isEmpty()) {
throw new IllegalArgumentException("Label map is empty.");
}
SortedMap<PlainTime, String> map = new TreeMap<PlainTime, String>(timeToLabels);
for (PlainTime key : timeToLabels.keySet()) {
if (key.getHour() == 24) {
map.put(PlainTime.midnightAtStartOfDay(), timeToLabels.get(key));
map.remove(key);
} else if (timeToLabels.get(key).isEmpty()) {
throw new IllegalArgumentException("Map has empty label: " + timeToLabels);
}
}
return new DayPeriod(null, "", map);
}
@Test
public void testOneGroupOfTwoInRange() {
// 12 AM - 1 AM
long start_time0_ms = new DateTime(2000, 1, 1, 0, 0, 0, 0, DTZ).getMillis();
long start_time0_s = TimeUnit.MILLISECONDS.toSeconds(start_time0_ms);
long end_time0_ms = start_time0_ms + TimeUnit.HOURS.toMillis(1);
long end_time0_s = TimeUnit.MILLISECONDS.toSeconds(end_time0_ms);
AgendaItem item0 = new AgendaItem();
item0.setEpochStartTime(start_time0_s);
item0.setEpochEndTime(end_time0_s);
// 12 AM - 1 AM
AgendaItem item1 = new AgendaItem();
item1.setEpochStartTime(start_time0_s);
item1.setEpochEndTime(end_time0_s);
long look_ahead = TimeUnit.DAYS.toMillis(1);
long now = start_time0_ms - look_ahead + 1; // Just inside of range
final List<AgendaItem> items_in = Arrays.asList(item0, item1);
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_time0_ms, dr.start);
assertEquals(end_time0_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));
}
private Map<Integer, Boolean> getReferencedUpdateCols(TIntObjectHashMap tempRefColUpdtd2DependentCols) {
int[] refKeyCols = this.container.getExtraTableInfo()
.getReferencedKeyColumns();
// check if any of the modified cols is a ref key column of a
// reference
// integrity constraint
// refKeyCols = fkInfo.colArray;
if (refKeyCols != null) {
SortedMap<Integer, Boolean> referencedImpactedColsMap = new TreeMap<Integer, Boolean>();
// SortedSet<Integer> onlyRefUpadtedCols = new TreeSet();
for (int i = 0; i < constants.changedColumnIds.length; ++i) {
int modColID = constants.changedColumnIds[i];
for (int refKeyColID : refKeyCols) {
if (refKeyColID == modColID) {
// onlyRefUpadtedCols.add(refKeyColID);
TIntHashSet dependentCols = new TIntHashSet(refKeyCols.length);
tempRefColUpdtd2DependentCols.put(refKeyColID, dependentCols);
referencedImpactedColsMap.put(refKeyColID, Boolean.TRUE);
addCompanionRefColsToMap(refKeyColID, referencedImpactedColsMap,
dependentCols);
}
}
}
return referencedImpactedColsMap;
}
else {
return null;
}
}
/**
* 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;
}
private SortedMap<String, Object> resolveAllUnconfiguredAttributesForTarget(
CommandRunnerParams params, BuckQueryEnvironment env, QueryBuildTarget target)
throws QueryException {
Map<String, Object> attributes = getAllUnconfiguredAttributesForTarget(params, env, target);
PatternsMatcher patternsMatcher = new PatternsMatcher(outputAttributes());
SortedMap<String, Object> convertedAttributes = new TreeMap<>();
if (!patternsMatcher.isMatchesNone()) {
for (Map.Entry<String, Object> attribute : attributes.entrySet()) {
String attributeName = attribute.getKey();
String snakeCaseKey = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, attributeName);
if (!patternsMatcher.matches(snakeCaseKey)) {
continue;
}
Object jsonObject = attribute.getValue();
if (!(jsonObject instanceof ListWithSelects)) {
convertedAttributes.put(snakeCaseKey, jsonObject);
continue;
}
convertedAttributes.put(
snakeCaseKey, resolveUnconfiguredAttribute((ListWithSelects) jsonObject));
}
}
if (patternsMatcher.matches(InternalTargetAttributeNames.DIRECT_DEPENDENCIES)) {
convertedAttributes.put(
InternalTargetAttributeNames.DIRECT_DEPENDENCIES,
env.getNode(target).getParseDeps().stream()
.map(Object::toString)
.collect(ImmutableList.toImmutableList()));
}
return convertedAttributes;
}
private void checkMap(String context, TypeDescriptor<?> type, Schema schema) {
if (!isSubtypeOf(type, SortedMap.class)) {
reportError(context, "%s may not be deterministically ordered", type);
}
// Avro (currently) asserts that all keys are strings.
// In case that changes, we double check that the key was a string:
Class<?> keyType = type.resolveType(Map.class.getTypeParameters()[0]).getRawType();
if (!String.class.equals(keyType)) {
reportError(context, "map keys should be Strings, but was %s", keyType);
}
recurse(context, type.resolveType(Map.class.getTypeParameters()[1]), schema.getValueType());
}
public void testNavigableSubMapSerialization() {
// Updated golden value since we have a different serialVersionUID in OpenJDK.
String s = "aced0005737200216a6176612e7574696c2e547265654d617024417363656e646"
+ "96e675375624d61700cab946d1f0fab1c020000787200216a6176612e7574696c2"
+ "e547265654d6170244e6176696761626c655375624d617026617d4eacdd5933020"
+ "0075a000966726f6d53746172745a000b6869496e636c75736976655a000b6c6f4"
+ "96e636c75736976655a0005746f456e644c000268697400124c6a6176612f6c616"
+ "e672f4f626a6563743b4c00026c6f71007e00024c00016d7400134c6a6176612f7"
+ "574696c2f547265654d61703b7870000100007400016374000161737200116a617"
+ "6612e7574696c2e547265654d61700cc1f63e2d256ae60300014c000a636f6d706"
+ "17261746f727400164c6a6176612f7574696c2f436f6d70617261746f723b78707"
+ "372002a6a6176612e6c616e672e537472696e672443617365496e73656e7369746"
+ "97665436f6d70617261746f7277035c7d5c50e5ce0200007870770400000004710"
+ "07e000671007e00067400016271007e000c71007e000571007e000574000164710"
+ "07e000d78";
TreeMap<String, String> map = new TreeMap<String, String>(
String.CASE_INSENSITIVE_ORDER);
map.put("a", "a");
map.put("b", "b");
map.put("c", "c");
map.put("d", "d");
SortedMap<String, String> subMap = map.subMap("a", false, "c", true);
new SerializationTester<SortedMap<String, String>>(subMap, s) {
@Override protected void verify(SortedMap<String, String> deserialized) {
try {
deserialized.put("e", "e");
fail();
} catch (IllegalArgumentException expected) {
}
}
}.test();
}
public static <V> Map<String, V> filterAttributes(Map<String, V> attributes) {
if (logger.traceOn()) {
logger.trace("filterAttributes", "starts");
}
SortedMap<String, V> map = new TreeMap<String, V>(attributes);
purgeUnserializable(map.values());
hideAttributes(map);
return map;
}
/**
* GenPolynomial subtraction.
*
* @param S
* GenPolynomial.
* @return this-S.
*/
@Override
public SymbolicPolynomial subtract(SymbolicPolynomial S) {
if (S == null) {
return this;
}
if (S.isZERO()) {
return this;
}
if (this.isZERO()) {
return S.negate();
}
assert (ring.nvar == S.ring.nvar);
SymbolicPolynomial n = this.copy(); // new GenPolynomial(ring, val);
SortedMap<ExpVectorSymbolic, IExpr> nv = n.val;
SortedMap<ExpVectorSymbolic, IExpr> sv = S.val;
for (Map.Entry<ExpVectorSymbolic, IExpr> me : sv.entrySet()) {
ExpVectorSymbolic e = me.getKey();
IExpr y = me.getValue(); // sv.get(e); // assert y != null
IExpr x = nv.get(e);
if (x != null) {
x = x.subtract(y);
if (!x.isZERO()) {
nv.put(e, x);
} else {
nv.remove(e);
}
} else {
nv.put(e, y.negate());
}
}
return n;
}
public static void shutdownMetrics(String indexerName) {
SortedMap<String, SortedMap<MetricName, Metric>> groupedMetrics = Metrics.defaultRegistry().groupedMetrics(
new IndexerMetricPredicate(indexerName));
for (SortedMap<MetricName, Metric> metricMap : groupedMetrics.values()) {
for (MetricName metricName : metricMap.keySet()) {
Metrics.defaultRegistry().removeMetric(metricName);
}
}
}