    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.collect.ImmutableMap;
    021    import com.google.common.collect.Maps;
    022    import com.google.common.util.concurrent.UncheckedExecutionException;
    023
    024    import java.util.Map;
    025    import java.util.concurrent.Callable;
    026    import java.util.concurrent.ExecutionException;
    027
    028    /**
    029     * This class provides a skeletal implementation of the {@code Cache} interface to minimize the
    030     * effort required to implement this interface.
    031     *
    032     * <p>To implement a cache, the programmer needs only to extend this class and provide an
    033     * implementation for the {@link #get(Object)} and {@link #getIfPresent} methods.
    034     * {@link #getUnchecked}, {@link #get(Object, Callable)}, and {@link #getAll} are implemented in
    035     * terms of {@code get}; {@link #getAllPresent} is implemented in terms of {@code getIfPresent};
    036     * {@link #putAll} is implemented in terms of {@link #put}, {@link #invalidateAll(Iterable)} is
    037     * implemented in terms of {@link #invalidate}. The method {@link #cleanUp} is a no-op. All other
    038     * methods throw an {@link UnsupportedOperationException}.
    039     *
    040     * @author Charles Fry
    041     * @since 11.0
    042     */
    043    @Beta
    044    public abstract class AbstractLoadingCache<K, V>
    045        extends AbstractCache<K, V> implements LoadingCache<K, V> {
    046
    047      /** Constructor for use by subclasses. */
    048      protected AbstractLoadingCache() {}
    049
    050      @Override
    051      public V getUnchecked(K key) {
    052        try {
    053          return get(key);
    054        } catch (ExecutionException e) {
    055          throw new UncheckedExecutionException(e.getCause());
    056        }
    057      }
    058
    059      @Override
    060      public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
    061        Map<K, V> result = Maps.newLinkedHashMap();
    062        for (K key : keys) {
    063          if (!result.containsKey(key)) {
    064            result.put(key, get(key));
    065          }
    066        }
    067        return ImmutableMap.copyOf(result);
    068      }
    069
    070      @Override
    071      public final V apply(K key) {
    072        return getUnchecked(key);
    073      }
    074
    075      @Override
    076      public void refresh(K key) {
    077        throw new UnsupportedOperationException();
    078      }
    079    }