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.ImmutableMap;
022    
023    import java.util.concurrent.ExecutionException;
024    
025    /**
026     * A cache which forwards all its method calls to another cache. Subclasses should override one or
027     * more methods to modify the behavior of the backing cache as desired per the
028     * <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
029     *
030     * <p>Note that {@link #get}, {@link #getUnchecked}, and {@link #apply} all expose the same
031     * underlying functionality, so should probably be overridden as a group.
032     *
033     * @author Charles Fry
034     * @since 11.0
035     */
036    @Beta
037    public abstract class ForwardingLoadingCache<K, V>
038        extends ForwardingCache<K, V> implements LoadingCache<K, V> {
039    
040      /** Constructor for use by subclasses. */
041      protected ForwardingLoadingCache() {}
042    
043      
044      @Override
045      protected abstract LoadingCache<K, V> delegate();
046    
047      public V get(K key) throws ExecutionException {
048        return delegate().get(key);
049      }
050    
051      public V getUnchecked(K key) {
052        return delegate().getUnchecked(key);
053      }
054    
055      public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
056        return delegate().getAll(keys);
057      }
058    
059      public V apply(K key) {
060        return delegate().apply(key);
061      }
062    
063      public void refresh(K key) {
064        delegate().refresh(key);
065      }
066    
067      /**
068       * A simplified version of {@link ForwardingLoadingCache} where subclasses can pass in an already
069       * constructed {@link LoadingCache} as the delegete.
070       *
071       * @since 10.0
072       */
073      @Beta
074      public abstract static class SimpleForwardingLoadingCache<K, V>
075          extends ForwardingLoadingCache<K, V> {
076        private final LoadingCache<K, V> delegate;
077    
078        protected SimpleForwardingLoadingCache(LoadingCache<K, V> delegate) {
079          this.delegate = Preconditions.checkNotNull(delegate);
080        }
081    
082        
083        @Override
084        protected final LoadingCache<K, V> delegate() {
085          return delegate;
086        }
087      }
088    }