All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.facebook.presto.jdbc.internal.guava.collect.MutableClassToInstanceMap Maven / Gradle / Ivy

There is a newer version: 0.289
Show newest version
/*
 * Copyright (C) 2007 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 com.facebook.presto.jdbc.internal.guava.collect;

import static com.facebook.presto.jdbc.internal.guava.base.Preconditions.checkNotNull;

import com.facebook.presto.jdbc.internal.guava.annotations.GwtIncompatible;
import com.facebook.presto.jdbc.internal.guava.primitives.Primitives;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.Spliterator;

/**
 * A mutable class-to-instance map backed by an arbitrary user-provided map. See also {@link
 * ImmutableClassToInstanceMap}.
 *
 * 

See the Guava User Guide article on {@code * ClassToInstanceMap}. * * @author Kevin Bourrillion * @since 2.0 */ @GwtIncompatible @SuppressWarnings("serial") // using writeReplace instead of standard serialization public final class MutableClassToInstanceMap extends ForwardingMap, B> implements ClassToInstanceMap, Serializable { /** * Returns a new {@code MutableClassToInstanceMap} instance backed by a {@link HashMap} using the * default initial capacity and load factor. */ public static MutableClassToInstanceMap create() { return new MutableClassToInstanceMap(new HashMap, B>()); } /** * Returns a new {@code MutableClassToInstanceMap} instance backed by a given empty {@code * backingMap}. The caller surrenders control of the backing map, and thus should not allow any * direct references to it to remain accessible. */ public static MutableClassToInstanceMap create(Map, B> backingMap) { return new MutableClassToInstanceMap(backingMap); } private final Map, B> delegate; private MutableClassToInstanceMap(Map, B> delegate) { this.delegate = checkNotNull(delegate); } @Override protected Map, B> delegate() { return delegate; } /** * Wraps the {@code setValue} implementation of an {@code Entry} to enforce the class constraint. */ private static Entry, B> checkedEntry( final Entry, B> entry) { return new ForwardingMapEntry, B>() { @Override protected Entry, B> delegate() { return entry; } @Override public B setValue(B value) { return super.setValue(cast(getKey(), value)); } }; } @Override public Set, B>> entrySet() { return new ForwardingSet, B>>() { @Override protected Set, B>> delegate() { return MutableClassToInstanceMap.this.delegate().entrySet(); } @Override public Spliterator, B>> spliterator() { return CollectSpliterators.map( delegate().spliterator(), MutableClassToInstanceMap::checkedEntry); } @Override public Iterator, B>> iterator() { return new TransformedIterator, B>, Entry, B>>( delegate().iterator()) { @Override Entry, B> transform(Entry, B> from) { return checkedEntry(from); } }; } @Override public Object[] toArray() { return standardToArray(); } @Override public T[] toArray(T[] array) { return standardToArray(array); } }; } @Override @CanIgnoreReturnValue public B put(Class key, B value) { return super.put(key, cast(key, value)); } @Override public void putAll(Map, ? extends B> map) { Map, B> copy = new LinkedHashMap<>(map); for (Entry, B> entry : copy.entrySet()) { cast(entry.getKey(), entry.getValue()); } super.putAll(copy); } @CanIgnoreReturnValue @Override public T putInstance(Class type, T value) { return cast(type, put(type, value)); } @Override public T getInstance(Class type) { return cast(type, get(type)); } @CanIgnoreReturnValue private static T cast(Class type, B value) { return Primitives.wrap(type).cast(value); } private Object writeReplace() { return new SerializedForm(delegate()); } /** Serialized form of the map, to avoid serializing the constraint. */ private static final class SerializedForm implements Serializable { private final Map, B> backingMap; SerializedForm(Map, B> backingMap) { this.backingMap = backingMap; } Object readResolve() { return create(backingMap); } private static final long serialVersionUID = 0; } }