com.google.common.collect.ForwardingMap Maven / Gradle / Ivy
Show all versions of google-collections Show documentation
/*
* Copyright (C) 2007 Google Inc.
*
* 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.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
/**
* A map which forwards all its method calls to another map. Subclasses should
* override one or more methods to modify the behavior of the backing map as
* desired per the decorator pattern.
*
* @see ForwardingObject
* @author Kevin Bourrillion
* @author Jared Levy
*/
@GwtCompatible
public abstract class ForwardingMap extends ForwardingObject
implements Map {
@Override protected abstract Map delegate();
public int size() {
return delegate().size();
}
public boolean isEmpty() {
return delegate().isEmpty();
}
public V remove(Object object) {
return delegate().remove(object);
}
public void clear() {
delegate().clear();
}
public boolean containsKey(Object key) {
return delegate().containsKey(key);
}
public boolean containsValue(Object value) {
return delegate().containsValue(value);
}
public V get(Object key) {
return delegate().get(key);
}
public V put(K key, V value) {
return delegate().put(key, value);
}
public void putAll(Map extends K, ? extends V> map) {
delegate().putAll(map);
}
private transient Set keySet;
public Set keySet() {
return (keySet == null) ? keySet = createKeySet() : keySet;
}
/**
* Generates a {@link Set} for use by {@link #keySet()}.
*
* ForwardingMap's implementation of keySet() calls this method to
* generate a collection of values, and then reuses that Set
* for subsequent invocations. By default, this Set is the
* result of invoking keySet() on the delegate. Override this method if you
* want to provide another implementation.
*
* @return A set for use by keySet().
*/
protected Set createKeySet() {
return delegate().keySet();
}
private transient Collection values;
public Collection values() {
return (values == null) ? values = createValues() : values;
}
/**
* Generates a {@link Collection} for use by {@link #values()}.
*
* ForwardingMap's implementation of {@code values()} calls this method to
* generate a collection of values, and then reuses that collection
* for subsequent invocations. By default, this collection is the
* result of invoking values() on the delegate. Override this method if you
* want to provide another implementation.
*
* @return A set for use by values().
*/
protected Collection createValues() {
return delegate().values();
}
private transient Set> entrySet;
public Set> entrySet() {
return (entrySet == null) ? entrySet = createEntrySet() : entrySet;
}
/**
* Generates a {@link Set} for use by {@link #entrySet()}.
*
* ForwardingMap's implementation of entrySet() calls this method to
* generate a set of entries, and then reuses that set for subsequent
* invocations. By default, this set is the result of invoking
* entrySet() on the delegate. Override this method if you want to
* provide another implementation.
*
* @return A set for use by entrySet().
*/
protected Set> createEntrySet() {
return delegate().entrySet();
}
@Override public boolean equals(@Nullable Object object) {
return object == this || delegate().equals(object);
}
@Override public int hashCode() {
return delegate().hashCode();
}
}