001/*
002 * Copyright (C) 2011 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package com.google.common.cache;
018
019import com.google.common.annotations.Beta;
020import com.google.common.base.Preconditions;
021import com.google.common.collect.ForwardingObject;
022import com.google.common.collect.ImmutableMap;
023
024import java.util.Map;
025import java.util.concurrent.Callable;
026import java.util.concurrent.ConcurrentMap;
027import java.util.concurrent.ExecutionException;
028
029import javax.annotation.Nullable;
030
031/**
032 * A cache which forwards all its method calls to another cache. Subclasses should override one or
033 * more methods to modify the behavior of the backing cache as desired per the
034 * <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
035 *
036 * @author Charles Fry
037 * @since 10.0
038 */
039@Beta
040public abstract class ForwardingCache<K, V> extends ForwardingObject implements Cache<K, V> {
041
042  /** Constructor for use by subclasses. */
043  protected ForwardingCache() {}
044
045  @Override
046  protected abstract Cache<K, V> delegate();
047
048  /**
049   * @since 11.0
050   */
051  @Override
052  @Nullable
053  public V getIfPresent(Object key) {
054    return delegate().getIfPresent(key);
055  }
056
057  /**
058   * @since 11.0
059   */
060  @Override
061  public V get(K key, Callable<? extends V> valueLoader) throws ExecutionException {
062    return delegate().get(key, valueLoader);
063  }
064
065  /**
066   * @since 11.0
067   */
068  @Override
069  public ImmutableMap<K, V> getAllPresent(Iterable<?> keys) {
070    return delegate().getAllPresent(keys);
071  }
072
073  /**
074   * @since 11.0
075   */
076  @Override
077  public void put(K key, V value) {
078    delegate().put(key, value);
079  }
080
081  /**
082   * @since 12.0
083   */
084  @Override
085  public void putAll(Map<? extends K,? extends V> m) {
086    delegate().putAll(m);
087  }
088
089  @Override
090  public void invalidate(Object key) {
091    delegate().invalidate(key);
092  }
093
094  /**
095   * @since 11.0
096   */
097  @Override
098  public void invalidateAll(Iterable<?> keys) {
099    delegate().invalidateAll(keys);
100  }
101
102  @Override
103  public void invalidateAll() {
104    delegate().invalidateAll();
105  }
106
107  @Override
108  public long size() {
109    return delegate().size();
110  }
111
112  @Override
113  public CacheStats stats() {
114    return delegate().stats();
115  }
116
117  @Override
118  public ConcurrentMap<K, V> asMap() {
119    return delegate().asMap();
120  }
121
122  @Override
123  public void cleanUp() {
124    delegate().cleanUp();
125  }
126
127  /**
128   * A simplified version of {@link ForwardingCache} where subclasses can pass in an already
129   * constructed {@link Cache} as the delegete.
130   *
131   * @since 10.0
132   */
133  @Beta
134  public abstract static class SimpleForwardingCache<K, V> extends ForwardingCache<K, V> {
135    private final Cache<K, V> delegate;
136
137    protected SimpleForwardingCache(Cache<K, V> delegate) {
138      this.delegate = Preconditions.checkNotNull(delegate);
139    }
140
141    @Override
142    protected final Cache<K, V> delegate() {
143      return delegate;
144    }
145  }
146}