Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 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.google.common.cache;
 
 
 import java.util.Map;
 
A cache which forwards all its method calls to another cache. Subclasses should override one or more methods to modify the behavior of the backing cache as desired per the decorator pattern.

Author(s):
Charles Fry
Since:
10.0
 
 public abstract class ForwardingCache<K, V> extends ForwardingObject implements Cache<K, V> {

  
Constructor for use by subclasses.
 
   protected ForwardingCache() {}
 
   @Override
   protected abstract Cache<K, V> delegate();

  

Since:
11.0
 
   @Override
   @Nullable
   public V getIfPresent(Object key) {
     return delegate().getIfPresent(key);
   }

  

Since:
11.0
 
   @Override
   public V get(K keyCallable<? extends V> valueLoaderthrows ExecutionException {
     return delegate().get(keyvalueLoader);
   }

  

Since:
11.0
 
   @Override
   public ImmutableMap<K, V> getAllPresent(Iterable<?> keys) {
     return delegate().getAllPresent(keys);
   }

  

Since:
11.0
 
   @Override
   public void put(K key, V value) {
     delegate().put(keyvalue);
   }

  

Since:
12.0
 
   @Override
   public void putAll(Map<? extends K,? extends V> m) {
     delegate().putAll(m);
   }
 
   @Override
   public void invalidate(Object key) {
     delegate().invalidate(key);
   }

  

Since:
11.0
 
   @Override
   public void invalidateAll(Iterable<?> keys) {
     delegate().invalidateAll(keys);
  }
  public void invalidateAll() {
  }
  public long size() {
    return delegate().size();
  }
  public CacheStats stats() {
    return delegate().stats();
  }
  public ConcurrentMap<K, V> asMap() {
    return delegate().asMap();
  }
  public void cleanUp() {
    delegate().cleanUp();
  }

  
A simplified version of ForwardingCache where subclasses can pass in an already constructed Cache as the delegete.

Since:
10.0
  @Beta
  public abstract static class SimpleForwardingCache<K, V> extends ForwardingCache<K, V> {
    private final Cache<K, V> delegate;
    protected SimpleForwardingCache(Cache<K, V> delegate) {
      this. = Preconditions.checkNotNull(delegate);
    }
    @Override
    protected final Cache<K, V> delegate() {
      return ;
    }
  }
New to GrepCode? Check out our FAQ X