    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
    017    package com.google.common.cache;
    018
    019    import com.google.common.annotations.Beta;
    020    import com.google.common.base.Preconditions;
    021    import com.google.common.collect.ForwardingObject;
    022    import com.google.common.collect.ImmutableMap;
    023
    024    import java.util.Map;
    025    import java.util.concurrent.Callable;
    026    import java.util.concurrent.ConcurrentMap;
    027    import java.util.concurrent.ExecutionException;
    028
    029    import 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
    040    public 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    }