org.apache.rocketmq.shaded.com.google.common.reflect.MutableTypeToInstanceMap Maven / Gradle / Ivy
/*
* Copyright (C) 2012 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package org.apache.rocketmq.shaded.com.google.common.reflect;
import static org.apache.rocketmq.shaded.com.google.common.base.Preconditions.checkNotNull;
import org.apache.rocketmq.shaded.com.google.common.collect.ForwardingMap;
import org.apache.rocketmq.shaded.com.google.common.collect.ForwardingMapEntry;
import org.apache.rocketmq.shaded.com.google.common.collect.ForwardingSet;
import org.apache.rocketmq.shaded.com.google.common.collect.Iterators;
import org.apache.rocketmq.shaded.com.google.common.collect.Maps;
import org.apache.rocketmq.shaded.com.google.errorprone.annotations.CanIgnoreReturnValue;
import org.apache.rocketmq.shaded.com.google.errorprone.annotations.DoNotCall;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;
/**
* A mutable type-to-instance map. See also {@link ImmutableTypeToInstanceMap}.
*
* This implementation does support null values, despite how it is annotated; see
* discussion at {@link TypeToInstanceMap}.
*
* @author Ben Yu
* @since 13.0
*/
@ElementTypesAreNonnullByDefault
public final class MutableTypeToInstanceMap extends ForwardingMap, B>
implements TypeToInstanceMap {
private final Map, B> backingMap = Maps.newHashMap();
@Override
@CheckForNull
public T getInstance(Class type) {
return trustedGet(TypeToken.of(type));
}
@Override
@CheckForNull
public T getInstance(TypeToken type) {
return trustedGet(type.rejectTypeVariables());
}
@Override
@CanIgnoreReturnValue
@CheckForNull
public T putInstance(Class type, T value) {
return trustedPut(TypeToken.of(type), value);
}
@Override
@CanIgnoreReturnValue
@CheckForNull
public T putInstance(TypeToken type, T value) {
return trustedPut(type.rejectTypeVariables(), value);
}
/**
* Not supported. Use {@link #putInstance} instead.
*
* @deprecated unsupported operation
* @throws UnsupportedOperationException always
*/
@CanIgnoreReturnValue
@Deprecated
@Override
@DoNotCall("Always throws UnsupportedOperationException")
@CheckForNull
public B put(TypeToken key, B value) {
throw new UnsupportedOperationException("Please use putInstance() instead.");
}
/**
* Not supported. Use {@link #putInstance} instead.
*
* @deprecated unsupported operation
* @throws UnsupportedOperationException always
*/
@Deprecated
@Override
@DoNotCall("Always throws UnsupportedOperationException")
public void putAll(Map, ? extends B> map) {
throw new UnsupportedOperationException("Please use putInstance() instead.");
}
@Override
public Set, B>> entrySet() {
return UnmodifiableEntry.transformEntries(super.entrySet());
}
@Override
protected Map, B> delegate() {
return backingMap;
}
@SuppressWarnings("unchecked") // value could not get in if not a T
@CheckForNull
private T trustedPut(TypeToken type, T value) {
return (T) backingMap.put(type, value);
}
@SuppressWarnings("unchecked") // value could not get in if not a T
@CheckForNull
private T trustedGet(TypeToken type) {
return (T) backingMap.get(type);
}
private static final class UnmodifiableEntry extends ForwardingMapEntry {
private final Entry delegate;
static Set> transformEntries(Set> entries) {
return new ForwardingSet>() {
@Override
protected Set> delegate() {
return entries;
}
@Override
public Iterator> iterator() {
return UnmodifiableEntry.transformEntries(super.iterator());
}
@Override
public Object[] toArray() {
/*
* standardToArray returns `@Nullable Object[]` rather than `Object[]` but only because it
* can be used with collections that may contain null. This collection is a collection of
* non-null Entry objects (Entry objects that might contain null values but are not
* themselves null), so we can treat it as a plain `Object[]`.
*/
@SuppressWarnings("nullness")
Object[] result = standardToArray();
return result;
}
@Override
@SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
public T[] toArray(T[] array) {
return standardToArray(array);
}
};
}
private static Iterator> transformEntries(Iterator> entries) {
return Iterators.transform(entries, UnmodifiableEntry::new);
}
private UnmodifiableEntry(java.util.Map.Entry delegate) {
this.delegate = checkNotNull(delegate);
}
@Override
protected Entry delegate() {
return delegate;
}
@Override
public V setValue(V value) {
throw new UnsupportedOperationException();
}
}
}