Java Code Examples for java.util.Collections#unmodifiableSortedMap()

@SuppressWarnings("unchecked")
private <T extends Metric> SortedMap<MetricName, T> getMetrics(Class<T> klass, MetricFilter filter) {
    final TreeMap<MetricName, T> timers = new TreeMap<MetricName, T>();
    for (Map.Entry<MetricName, Metric> entry : metrics.entrySet()) {
        if (klass.isInstance(entry.getValue()) && filter.matches(entry.getKey(),
                entry.getValue())) {
            timers.put(entry.getKey(), (T) entry.getValue());
        } else if (entry.getValue() instanceof DynamicMetricSet) {
            for (Map.Entry<MetricName, Metric> dynamicEntry:
                    ((DynamicMetricSet) entry.getValue()).getDynamicMetrics().entrySet()) {
                if (klass.isInstance(dynamicEntry.getValue()) &&
                        filter.matches(dynamicEntry.getKey(), dynamicEntry.getValue())) {
                    timers.put(dynamicEntry.getKey(), (T) dynamicEntry.getValue());
                }
            }
        }
    }
    return Collections.unmodifiableSortedMap(timers);
}
 

/**
 * java.util.Collections#unmodifiableSortedMap(java.util.SortedMap)
 */
public void test_unmodifiableSortedMapLjava_util_SortedMap() {
    try {
        // Regression for HARMONY-93
        Collections.unmodifiableSortedMap(null);
        fail("Assert 0: unmodifiableSortedMap(null) must throw NPE");
    } catch (NullPointerException e) {
        // expected
    }
}
 

public ModifyContextImpl ( final String channelId, final BlobStore store, final CacheStore cacheStore, final ChannelState state, final Map<String, String> aspectStates, final Map<String, ArtifactInformation> artifacts, final Map<MetaKey, CacheEntryInformation> cacheEntries, final Map<MetaKey, String> extractedMetaData, final Map<MetaKey, String> providedMetaData )
{
    Objects.requireNonNull ( channelId );
    Objects.requireNonNull ( store );
    Objects.requireNonNull ( cacheStore );

    this.channelId = channelId;

    this.store = store;
    this.cacheStore = cacheStore;

    this.state = new Builder ( state );

    // main collections

    this.modAspectStates = new TreeMap<> ( aspectStates );
    this.modCacheEntries = new HashMap<> ( cacheEntries );
    this.modArtifacts = new HashMap<> ( artifacts );
    this.modGeneratorArtifacts = this.modArtifacts.values ().stream ().filter ( art -> art.is ( FACET_GENERATOR ) ).collect ( toMap ( ArtifactInformation::getId, a -> a ) );
    this.modExtractedMetadata = new HashMap<> ( extractedMetaData );
    this.modProvidedMetadata = new HashMap<> ( providedMetaData );

    // create unmodifiable collections

    this.aspectStates = Collections.unmodifiableSortedMap ( this.modAspectStates );
    this.cacheEntries = Collections.unmodifiableMap ( this.modCacheEntries );
    this.artifacts = Collections.unmodifiableMap ( this.modArtifacts );
    this.generatorArtifacts = Collections.unmodifiableMap ( this.modGeneratorArtifacts );
    this.extractedMetadata = Collections.unmodifiableMap ( this.modExtractedMetadata );
    this.providedMetadata = Collections.unmodifiableMap ( this.modProvidedMetadata );

    // aspect context

    this.aspectContext = new AspectContextImpl ( this, Activator.getProcessor () );
}
 

/**
 * java.util.Collections#unmodifiableSortedMap(java.util.SortedMap)
 */
public void test_unmodifiableSortedMapLjava_util_SortedMap() {
    try {
        // Regression for HARMONY-93
        Collections.unmodifiableSortedMap(null);
        fail("Assert 0: unmodifiableSortedMap(null) must throw NPE");
    } catch (NullPointerException e) {
        // expected
    }
}
 

public static SortedMap<String, java.nio.charset.Charset> availableCharsets() {
    final TreeMap<String, java.nio.charset.Charset> m =
            new TreeMap<>(
                    String.CASE_INSENSITIVE_ORDER);
    put(standardProvider.charsets(), m);
    return Collections.unmodifiableSortedMap(m);
}
 

private static <K, V> Map<K, V> unmodifiableMap(Map<K, ? extends V> map) {
  if (map instanceof SortedMap) {
    return Collections.unmodifiableSortedMap((SortedMap<K, ? extends V>) map);
  } else {
    return Collections.unmodifiableMap(map);
  }
}
 

private DayPeriod(
    Locale locale, // optional
    String calendarType,
    SortedMap<PlainTime, String> codeMap
) {
    super();

    this.locale = locale;
    this.calendarType = calendarType;
    this.codeMap = Collections.unmodifiableSortedMap(codeMap);

}
 

private static <K, V> Map<K, V> unmodifiableMap(Map<K, ? extends V> map) {
  if (map instanceof SortedMap) {
    return Collections.unmodifiableSortedMap((SortedMap<K, ? extends V>) map);
  } else {
    return Collections.unmodifiableMap(map);
  }
}
 

private ChannelInformation ( final String id, final Set<String> names, final String description, final ChannelState state, final SortedMap<MetaKey, String> metaData, final SortedMap<String, String> aspectStates )
{
    super ( id, names, description );

    this.state = state;
    this.metaData = Collections.unmodifiableSortedMap ( metaData );
    this.aspectStates = Collections.unmodifiableSortedMap ( aspectStates );
}
 

public void setKeyLabels(Map<String, String> keyLabels) {
    if (keyLabels == null || keyLabels.isEmpty()) {
        throw new IllegalArgumentException("keyLabels must be non-null & non-empty");
    }
    // keep previously SortedMaps (such as by sequence number) sorted. 
    if (keyLabels instanceof SortedMap) {
        this.keyLabels = Collections.unmodifiableSortedMap((SortedMap)keyLabels);
    } else {
        this.keyLabels = Collections.unmodifiableMap(new LinkedHashMap<String, String>(keyLabels));
    }
}
 

protected SortedMap<String, String> getAnotherObject() {
    SortedMap<String, String> map = new TreeMap<String, String>();
    return Collections.unmodifiableSortedMap(map);
}
 

protected SortedMap<String, String> getAnotherObject() {
    SortedMap<String, String> map = new TreeMap<String, String>();
    return Collections.unmodifiableSortedMap(map);
}
 

protected SortedMap<String, String> getObject() {
    SortedMap<String, String> map = new TreeMap<String, String>();
    map.put("key", "value");
    return Collections.unmodifiableSortedMap(map);
}
 

private MetricId(String key, SortedMap<String, String> tags, boolean isAlreadyUnmodifiable) {
    this.key = key;
    this.tags = isAlreadyUnmodifiable ? tags : Collections.unmodifiableSortedMap(tags);
    this.hash = calculateHashCode(key, tags);
}
 

@Nullable
@Override
public T get(ConfigPropertyValue<T> propertyValue)
{
    T rawValue = propertyValue.getRawValue();
    if (rawValue == null)
    {
        return null;
    }
    if (this.returnUnmodifiableCollections)
    {
        if (rawValue instanceof Collection)
        {
            if (rawValue instanceof Set)
            {
                if (rawValue instanceof NavigableSet)
                {
                    return (T) Collections.unmodifiableNavigableSet((NavigableSet<?>) rawValue);
                }
                if (rawValue instanceof SortedSet)
                {
                    return (T) Collections.unmodifiableSortedSet((SortedSet<?>) rawValue);
                }
                return (T) Collections.unmodifiableSet((Set<?>) rawValue);
            }
            if (rawValue instanceof List)
            {
                return (T) Collections.unmodifiableList((List<?>) rawValue);
            }
            return (T) Collections.unmodifiableCollection((Collection<?>) rawValue);
        }
        else if (rawValue instanceof Map)
        {
            if (rawValue instanceof NavigableMap)
            {
                return (T) Collections.unmodifiableNavigableMap((NavigableMap<?, ?>) rawValue);
            }
            if (rawValue instanceof SortedMap)
            {
                return (T) Collections.unmodifiableSortedMap((SortedMap<?, ?>) rawValue);
            }
            return (T) Collections.unmodifiableMap((Map<?, ?>) rawValue);
        }
    }
    return rawValue;
}
 

@Override
public SortedMap<R, Map<C, V>> rowMap() {
  Function<Map<C, V>, Map<C, V>> wrapper = unmodifiableWrapper();
  return Collections.unmodifiableSortedMap(Maps.transformValues(delegate().rowMap(), wrapper));
}
 

@Override
public SortedMap<R, Map<C, V>> rowMap() {
  Function<Map<C, V>, Map<C, V>> wrapper = unmodifiableWrapper();
  return Collections.unmodifiableSortedMap(Maps.transformValues(delegate().rowMap(), wrapper));
}
 

public SortedMap<String, String> getAspects ()
{
    return Collections.unmodifiableSortedMap ( this.map );
}
 

protected SortedMap<String, String> getObject() {
    SortedMap<String, String> map = new TreeMap<String, String>();
    map.put("key", "value");
    return Collections.unmodifiableSortedMap(map);
}
 

/**
 * Get temporal operators
 *
 * @return temporal operators
 */
public SortedMap<TimeOperator, SortedSet<QName>> getTemporalOperators() {
    return Collections.unmodifiableSortedMap(temporalOperators);
}