001/*
002 * Copyright (C) 2009 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.cache;
016
017import static com.google.common.base.Preconditions.checkArgument;
018import static com.google.common.base.Preconditions.checkNotNull;
019import static com.google.common.base.Preconditions.checkState;
020
021import com.google.common.annotations.GwtCompatible;
022import com.google.common.annotations.GwtIncompatible;
023import com.google.common.base.Ascii;
024import com.google.common.base.Equivalence;
025import com.google.common.base.MoreObjects;
026import com.google.common.base.Supplier;
027import com.google.common.base.Suppliers;
028import com.google.common.base.Ticker;
029import com.google.common.cache.AbstractCache.SimpleStatsCounter;
030import com.google.common.cache.AbstractCache.StatsCounter;
031import com.google.common.cache.LocalCache.Strength;
032import com.google.errorprone.annotations.CanIgnoreReturnValue;
033import com.google.j2objc.annotations.J2ObjCIncompatible;
034import java.lang.ref.SoftReference;
035import java.lang.ref.WeakReference;
036import java.util.ConcurrentModificationException;
037import java.util.IdentityHashMap;
038import java.util.Map;
039import java.util.concurrent.TimeUnit;
040import java.util.logging.Level;
041import java.util.logging.Logger;
042import javax.annotation.CheckForNull;
043
044/**
045 * A builder of {@link LoadingCache} and {@link Cache} instances.
046 *
047 * <h2>Prefer <a href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a> over Guava's caching
048 * API</h2>
049 *
050 * <p>The successor to Guava's caching API is <a
051 * href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a>. Its API is designed to make it a
052 * nearly drop-in replacement -- though it requires Java 8 APIs, is not available for Android or
053 * GWT/j2cl, and may have <a href="https://github.com/ben-manes/caffeine/wiki/Guava">different
054 * (usually better) behavior</a> when multiple threads attempt concurrent mutations. Its equivalent
055 * to {@code CacheBuilder} is its <a
056 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/Caffeine.html">{@code
057 * Caffeine}</a> class. Caffeine offers better performance, more features (including asynchronous
058 * loading), and fewer <a
059 * href="https://github.com/google/guava/issues?q=is%3Aopen+is%3Aissue+label%3Apackage%3Dcache+label%3Atype%3Ddefect">bugs</a>.
060 *
061 * <p>Caffeine defines its own interfaces (<a
062 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/Cache.html">{@code
063 * Cache}</a>, <a
064 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/LoadingCache.html">{@code
065 * LoadingCache}</a>, <a
066 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/CacheLoader.html">{@code
067 * CacheLoader}</a>, etc.), so you can use Caffeine without needing to use any Guava types.
068 * Caffeine's types are better than Guava's, especially for <a
069 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/AsyncLoadingCache.html">their
070 * deep support for asynchronous operations</a>. But if you want to migrate to Caffeine with minimal
071 * code changes, you can use <a
072 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/guava/latest/com.github.benmanes.caffeine.guava/com/github/benmanes/caffeine/guava/CaffeinatedGuava.html">its
073 * {@code CaffeinatedGuava} adapter class</a>, which lets you build a Guava {@code Cache} or a Guava
074 * {@code LoadingCache} backed by a Guava {@code CacheLoader}.
075 *
076 * <p>Caffeine's API for asynchronous operations uses {@code CompletableFuture}: <a
077 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/AsyncLoadingCache.html#get(K)">{@code
078 * AsyncLoadingCache.get}</a> returns a {@code CompletableFuture}, and implementations of <a
079 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/AsyncCacheLoader.html#asyncLoad(K,java.util.concurrent.Executor)">{@code
080 * AsyncCacheLoader.asyncLoad}</a> must return a {@code CompletableFuture}. Users of Guava's {@link
081 * com.google.common.util.concurrent.ListenableFuture} can adapt between the two {@code Future}
082 * types by using <a href="https://github.com/lukas-krecan/future-converter#java8-guava">{@code
083 * net.javacrumbs.futureconverter.java8guava.FutureConverter}</a>.
084 *
085 * <h2>More on {@code CacheBuilder}</h2>
086 *
087 * {@code CacheBuilder} builds caches with any combination of the following features:
088 *
089 * <ul>
090 *   <li>automatic loading of entries into the cache
091 *   <li>least-recently-used eviction when a maximum size is exceeded (note that the cache is
092 *       divided into segments, each of which does LRU internally)
093 *   <li>time-based expiration of entries, measured since last access or last write
094 *   <li>keys automatically wrapped in {@code WeakReference}
095 *   <li>values automatically wrapped in {@code WeakReference} or {@code SoftReference}
096 *   <li>notification of evicted (or otherwise removed) entries
097 *   <li>accumulation of cache access statistics
098 * </ul>
099 *
100 * <p>These features are all optional; caches can be created using all or none of them. By default,
101 * cache instances created by {@code CacheBuilder} will not perform any type of eviction.
102 *
103 * <p>Usage example:
104 *
105 * <pre>{@code
106 * LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
107 *     .maximumSize(10000)
108 *     .expireAfterWrite(Duration.ofMinutes(10))
109 *     .removalListener(MY_LISTENER)
110 *     .build(
111 *         new CacheLoader<Key, Graph>() {
112 *           public Graph load(Key key) throws AnyException {
113 *             return createExpensiveGraph(key);
114 *           }
115 *         });
116 * }</pre>
117 *
118 * <p>Or equivalently,
119 *
120 * <pre>{@code
121 * // In real life this would come from a command-line flag or config file
122 * String spec = "maximumSize=10000,expireAfterWrite=10m";
123 *
124 * LoadingCache<Key, Graph> graphs = CacheBuilder.from(spec)
125 *     .removalListener(MY_LISTENER)
126 *     .build(
127 *         new CacheLoader<Key, Graph>() {
128 *           public Graph load(Key key) throws AnyException {
129 *             return createExpensiveGraph(key);
130 *           }
131 *         });
132 * }</pre>
133 *
134 * <p>The returned cache implements all optional operations of the {@link LoadingCache} and {@link
135 * Cache} interfaces. The {@code asMap} view (and its collection views) have <i>weakly consistent
136 * iterators</i>. This means that they are safe for concurrent use, but if other threads modify the
137 * cache after the iterator is created, it is undefined which of these changes, if any, are
138 * reflected in that iterator. These iterators never throw {@link ConcurrentModificationException}.
139 *
140 * <p><b>Note:</b> by default, the returned cache uses equality comparisons (the {@link
141 * Object#equals equals} method) to determine equality for keys or values. However, if {@link
142 * #weakKeys} was specified, the cache uses identity ({@code ==}) comparisons instead for keys.
143 * Likewise, if {@link #weakValues} or {@link #softValues} was specified, the cache uses identity
144 * comparisons for values.
145 *
146 * <p>Entries are automatically evicted from the cache when any of {@link #maximumSize(long)
147 * maximumSize}, {@link #maximumWeight(long) maximumWeight}, {@link #expireAfterWrite
148 * expireAfterWrite}, {@link #expireAfterAccess expireAfterAccess}, {@link #weakKeys weakKeys},
149 * {@link #weakValues weakValues}, or {@link #softValues softValues} are requested.
150 *
151 * <p>If {@link #maximumSize(long) maximumSize} or {@link #maximumWeight(long) maximumWeight} is
152 * requested entries may be evicted on each cache modification.
153 *
154 * <p>If {@link #expireAfterWrite expireAfterWrite} or {@link #expireAfterAccess expireAfterAccess}
155 * is requested entries may be evicted on each cache modification, on occasional cache accesses, or
156 * on calls to {@link Cache#cleanUp}. Expired entries may be counted by {@link Cache#size}, but will
157 * never be visible to read or write operations.
158 *
159 * <p>If {@link #weakKeys weakKeys}, {@link #weakValues weakValues}, or {@link #softValues
160 * softValues} are requested, it is possible for a key or value present in the cache to be reclaimed
161 * by the garbage collector. Entries with reclaimed keys or values may be removed from the cache on
162 * each cache modification, on occasional cache accesses, or on calls to {@link Cache#cleanUp}; such
163 * entries may be counted in {@link Cache#size}, but will never be visible to read or write
164 * operations.
165 *
166 * <p>Certain cache configurations will result in the accrual of periodic maintenance tasks which
167 * will be performed during write operations, or during occasional read operations in the absence of
168 * writes. The {@link Cache#cleanUp} method of the returned cache will also perform maintenance, but
169 * calling it should not be necessary with a high throughput cache. Only caches built with {@link
170 * #removalListener removalListener}, {@link #expireAfterWrite expireAfterWrite}, {@link
171 * #expireAfterAccess expireAfterAccess}, {@link #weakKeys weakKeys}, {@link #weakValues
172 * weakValues}, or {@link #softValues softValues} perform periodic maintenance.
173 *
174 * <p>The caches produced by {@code CacheBuilder} are serializable, and the deserialized caches
175 * retain all the configuration properties of the original cache. Note that the serialized form does
176 * <i>not</i> include cache contents, but only configuration.
177 *
178 * <p>See the Guava User Guide article on <a
179 * href="https://github.com/google/guava/wiki/CachesExplained">caching</a> for a higher-level
180 * explanation.
181 *
182 * @param <K> the most general key type this builder will be able to create caches for. This is
183 *     normally {@code Object} unless it is constrained by using a method like {@code
184 *     #removalListener}. Cache keys may not be null.
185 * @param <V> the most general value type this builder will be able to create caches for. This is
186 *     normally {@code Object} unless it is constrained by using a method like {@code
187 *     #removalListener}. Cache values may not be null.
188 * @author Charles Fry
189 * @author Kevin Bourrillion
190 * @since 10.0
191 */
192@GwtCompatible(emulated = true)
193@ElementTypesAreNonnullByDefault
194public final class CacheBuilder<K, V> {
195  private static final int DEFAULT_INITIAL_CAPACITY = 16;
196  private static final int DEFAULT_CONCURRENCY_LEVEL = 4;
197
198  @SuppressWarnings("GoodTime") // should be a java.time.Duration
199  private static final int DEFAULT_EXPIRATION_NANOS = 0;
200
201  @SuppressWarnings("GoodTime") // should be a java.time.Duration
202  private static final int DEFAULT_REFRESH_NANOS = 0;
203
204  static final Supplier<? extends StatsCounter> NULL_STATS_COUNTER =
205      Suppliers.ofInstance(
206          new StatsCounter() {
207            @Override
208            public void recordHits(int count) {}
209
210            @Override
211            public void recordMisses(int count) {}
212
213            @SuppressWarnings("GoodTime") // b/122668874
214            @Override
215            public void recordLoadSuccess(long loadTime) {}
216
217            @SuppressWarnings("GoodTime") // b/122668874
218            @Override
219            public void recordLoadException(long loadTime) {}
220
221            @Override
222            public void recordEviction() {}
223
224            @Override
225            public CacheStats snapshot() {
226              return EMPTY_STATS;
227            }
228          });
229  static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0);
230
231  /*
232   * We avoid using a method reference or lambda here for now:
233   *
234   * - method reference: Inside Google, CacheBuilder is used from the implementation of a custom
235   *   ClassLoader that is sometimes used as a system classloader. That's a problem because
236   *   method-reference linking tries to look up the system classloader, and it fails because there
237   *   isn't one yet.
238   *
239   * - lambda: Outside Google, we got a report of a similar problem in
240   *   https://github.com/google/guava/issues/6565
241   */
242  @SuppressWarnings("AnonymousToLambda")
243  static final Supplier<StatsCounter> CACHE_STATS_COUNTER =
244      new Supplier<StatsCounter>() {
245        @Override
246        public StatsCounter get() {
247          return new SimpleStatsCounter();
248        }
249      };
250
251  enum NullListener implements RemovalListener<Object, Object> {
252    INSTANCE;
253
254    @Override
255    public void onRemoval(RemovalNotification<Object, Object> notification) {}
256  }
257
258  enum OneWeigher implements Weigher<Object, Object> {
259    INSTANCE;
260
261    @Override
262    public int weigh(Object key, Object value) {
263      return 1;
264    }
265  }
266
267  static final Ticker NULL_TICKER =
268      new Ticker() {
269        @Override
270        public long read() {
271          return 0;
272        }
273      };
274
275  // We use a holder class to delay initialization: https://github.com/google/guava/issues/6566
276  private static final class LoggerHolder {
277    static final Logger logger = Logger.getLogger(CacheBuilder.class.getName());
278  }
279
280  static final int UNSET_INT = -1;
281
282  boolean strictParsing = true;
283
284  int initialCapacity = UNSET_INT;
285  int concurrencyLevel = UNSET_INT;
286  long maximumSize = UNSET_INT;
287  long maximumWeight = UNSET_INT;
288  @CheckForNull Weigher<? super K, ? super V> weigher;
289
290  @CheckForNull Strength keyStrength;
291  @CheckForNull Strength valueStrength;
292
293  @SuppressWarnings("GoodTime") // should be a java.time.Duration
294  long expireAfterWriteNanos = UNSET_INT;
295
296  @SuppressWarnings("GoodTime") // should be a java.time.Duration
297  long expireAfterAccessNanos = UNSET_INT;
298
299  @SuppressWarnings("GoodTime") // should be a java.time.Duration
300  long refreshNanos = UNSET_INT;
301
302  @CheckForNull Equivalence<Object> keyEquivalence;
303  @CheckForNull Equivalence<Object> valueEquivalence;
304
305  @CheckForNull RemovalListener<? super K, ? super V> removalListener;
306  @CheckForNull Ticker ticker;
307
308  Supplier<? extends StatsCounter> statsCounterSupplier = NULL_STATS_COUNTER;
309
310  private CacheBuilder() {}
311
312  /**
313   * Constructs a new {@code CacheBuilder} instance with default settings, including strong keys,
314   * strong values, and no automatic eviction of any kind.
315   *
316   * <p>Note that while this return type is {@code CacheBuilder<Object, Object>}, type parameters on
317   * the {@link #build} methods allow you to create a cache of any key and value type desired.
318   */
319  public static CacheBuilder<Object, Object> newBuilder() {
320    return new CacheBuilder<>();
321  }
322
323  /**
324   * Constructs a new {@code CacheBuilder} instance with the settings specified in {@code spec}.
325   *
326   * @since 12.0
327   */
328  @GwtIncompatible // To be supported
329  public static CacheBuilder<Object, Object> from(CacheBuilderSpec spec) {
330    return spec.toCacheBuilder().lenientParsing();
331  }
332
333  /**
334   * Constructs a new {@code CacheBuilder} instance with the settings specified in {@code spec}.
335   * This is especially useful for command-line configuration of a {@code CacheBuilder}.
336   *
337   * @param spec a String in the format specified by {@link CacheBuilderSpec}
338   * @since 12.0
339   */
340  @GwtIncompatible // To be supported
341  public static CacheBuilder<Object, Object> from(String spec) {
342    return from(CacheBuilderSpec.parse(spec));
343  }
344
345  /**
346   * Enables lenient parsing. Useful for tests and spec parsing.
347   *
348   * @return this {@code CacheBuilder} instance (for chaining)
349   */
350  @GwtIncompatible // To be supported
351  @CanIgnoreReturnValue
352  CacheBuilder<K, V> lenientParsing() {
353    strictParsing = false;
354    return this;
355  }
356
357  /**
358   * Sets a custom {@code Equivalence} strategy for comparing keys.
359   *
360   * <p>By default, the cache uses {@link Equivalence#identity} to determine key equality when
361   * {@link #weakKeys} is specified, and {@link Equivalence#equals()} otherwise.
362   *
363   * @return this {@code CacheBuilder} instance (for chaining)
364   */
365  @GwtIncompatible // To be supported
366  @CanIgnoreReturnValue
367  CacheBuilder<K, V> keyEquivalence(Equivalence<Object> equivalence) {
368    checkState(keyEquivalence == null, "key equivalence was already set to %s", keyEquivalence);
369    keyEquivalence = checkNotNull(equivalence);
370    return this;
371  }
372
373  Equivalence<Object> getKeyEquivalence() {
374    return MoreObjects.firstNonNull(keyEquivalence, getKeyStrength().defaultEquivalence());
375  }
376
377  /**
378   * Sets a custom {@code Equivalence} strategy for comparing values.
379   *
380   * <p>By default, the cache uses {@link Equivalence#identity} to determine value equality when
381   * {@link #weakValues} or {@link #softValues} is specified, and {@link Equivalence#equals()}
382   * otherwise.
383   *
384   * @return this {@code CacheBuilder} instance (for chaining)
385   */
386  @GwtIncompatible // To be supported
387  @CanIgnoreReturnValue
388  CacheBuilder<K, V> valueEquivalence(Equivalence<Object> equivalence) {
389    checkState(
390        valueEquivalence == null, "value equivalence was already set to %s", valueEquivalence);
391    this.valueEquivalence = checkNotNull(equivalence);
392    return this;
393  }
394
395  Equivalence<Object> getValueEquivalence() {
396    return MoreObjects.firstNonNull(valueEquivalence, getValueStrength().defaultEquivalence());
397  }
398
399  /**
400   * Sets the minimum total size for the internal hash tables. For example, if the initial capacity
401   * is {@code 60}, and the concurrency level is {@code 8}, then eight segments are created, each
402   * having a hash table of size eight. Providing a large enough estimate at construction time
403   * avoids the need for expensive resizing operations later, but setting this value unnecessarily
404   * high wastes memory.
405   *
406   * @return this {@code CacheBuilder} instance (for chaining)
407   * @throws IllegalArgumentException if {@code initialCapacity} is negative
408   * @throws IllegalStateException if an initial capacity was already set
409   */
410  @CanIgnoreReturnValue
411  public CacheBuilder<K, V> initialCapacity(int initialCapacity) {
412    checkState(
413        this.initialCapacity == UNSET_INT,
414        "initial capacity was already set to %s",
415        this.initialCapacity);
416    checkArgument(initialCapacity >= 0);
417    this.initialCapacity = initialCapacity;
418    return this;
419  }
420
421  int getInitialCapacity() {
422    return (initialCapacity == UNSET_INT) ? DEFAULT_INITIAL_CAPACITY : initialCapacity;
423  }
424
425  /**
426   * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The
427   * table is internally partitioned to try to permit the indicated number of concurrent updates
428   * without contention. Because assignment of entries to these partitions is not necessarily
429   * uniform, the actual concurrency observed may vary. Ideally, you should choose a value to
430   * accommodate as many threads as will ever concurrently modify the table. Using a significantly
431   * higher value than you need can waste space and time, and a significantly lower value can lead
432   * to thread contention. But overestimates and underestimates within an order of magnitude do not
433   * usually have much noticeable impact. A value of one permits only one thread to modify the cache
434   * at a time, but since read operations and cache loading computations can proceed concurrently,
435   * this still yields higher concurrency than full synchronization.
436   *
437   * <p>Defaults to 4. <b>Note:</b>The default may change in the future. If you care about this
438   * value, you should always choose it explicitly.
439   *
440   * <p>The current implementation uses the concurrency level to create a fixed number of hashtable
441   * segments, each governed by its own write lock. The segment lock is taken once for each explicit
442   * write, and twice for each cache loading computation (once prior to loading the new value, and
443   * once after loading completes). Much internal cache management is performed at the segment
444   * granularity. For example, access queues and write queues are kept per segment when they are
445   * required by the selected eviction algorithm. As such, when writing unit tests it is not
446   * uncommon to specify {@code concurrencyLevel(1)} in order to achieve more deterministic eviction
447   * behavior.
448   *
449   * <p>Note that future implementations may abandon segment locking in favor of more advanced
450   * concurrency controls.
451   *
452   * @return this {@code CacheBuilder} instance (for chaining)
453   * @throws IllegalArgumentException if {@code concurrencyLevel} is nonpositive
454   * @throws IllegalStateException if a concurrency level was already set
455   */
456  @CanIgnoreReturnValue
457  public CacheBuilder<K, V> concurrencyLevel(int concurrencyLevel) {
458    checkState(
459        this.concurrencyLevel == UNSET_INT,
460        "concurrency level was already set to %s",
461        this.concurrencyLevel);
462    checkArgument(concurrencyLevel > 0);
463    this.concurrencyLevel = concurrencyLevel;
464    return this;
465  }
466
467  int getConcurrencyLevel() {
468    return (concurrencyLevel == UNSET_INT) ? DEFAULT_CONCURRENCY_LEVEL : concurrencyLevel;
469  }
470
471  /**
472   * Specifies the maximum number of entries the cache may contain.
473   *
474   * <p>Note that the cache <b>may evict an entry before this limit is exceeded</b>. For example, in
475   * the current implementation, when {@code concurrencyLevel} is greater than {@code 1}, each
476   * resulting segment inside the cache <i>independently</i> limits its own size to approximately
477   * {@code maximumSize / concurrencyLevel}.
478   *
479   * <p>When eviction is necessary, the cache evicts entries that are less likely to be used again.
480   * For example, the cache may evict an entry because it hasn't been used recently or very often.
481   *
482   * <p>If {@code maximumSize} is zero, elements will be evicted immediately after being loaded into
483   * cache. This can be useful in testing, or to disable caching temporarily.
484   *
485   * <p>This feature cannot be used in conjunction with {@link #maximumWeight}.
486   *
487   * @param maximumSize the maximum size of the cache
488   * @return this {@code CacheBuilder} instance (for chaining)
489   * @throws IllegalArgumentException if {@code maximumSize} is negative
490   * @throws IllegalStateException if a maximum size or weight was already set
491   */
492  @CanIgnoreReturnValue
493  public CacheBuilder<K, V> maximumSize(long maximumSize) {
494    checkState(
495        this.maximumSize == UNSET_INT, "maximum size was already set to %s", this.maximumSize);
496    checkState(
497        this.maximumWeight == UNSET_INT,
498        "maximum weight was already set to %s",
499        this.maximumWeight);
500    checkState(this.weigher == null, "maximum size can not be combined with weigher");
501    checkArgument(maximumSize >= 0, "maximum size must not be negative");
502    this.maximumSize = maximumSize;
503    return this;
504  }
505
506  /**
507   * Specifies the maximum weight of entries the cache may contain. Weight is determined using the
508   * {@link Weigher} specified with {@link #weigher}, and use of this method requires a
509   * corresponding call to {@link #weigher} prior to calling {@link #build}.
510   *
511   * <p>Note that the cache <b>may evict an entry before this limit is exceeded</b>. For example, in
512   * the current implementation, when {@code concurrencyLevel} is greater than {@code 1}, each
513   * resulting segment inside the cache <i>independently</i> limits its own weight to approximately
514   * {@code maximumWeight / concurrencyLevel}.
515   *
516   * <p>When eviction is necessary, the cache evicts entries that are less likely to be used again.
517   * For example, the cache may evict an entry because it hasn't been used recently or very often.
518   *
519   * <p>If {@code maximumWeight} is zero, elements will be evicted immediately after being loaded
520   * into cache. This can be useful in testing, or to disable caching temporarily.
521   *
522   * <p>Note that weight is only used to determine whether the cache is over capacity; it has no
523   * effect on selecting which entry should be evicted next.
524   *
525   * <p>This feature cannot be used in conjunction with {@link #maximumSize}.
526   *
527   * @param maximumWeight the maximum total weight of entries the cache may contain
528   * @return this {@code CacheBuilder} instance (for chaining)
529   * @throws IllegalArgumentException if {@code maximumWeight} is negative
530   * @throws IllegalStateException if a maximum weight or size was already set
531   * @since 11.0
532   */
533  @GwtIncompatible // To be supported
534  @CanIgnoreReturnValue
535  public CacheBuilder<K, V> maximumWeight(long maximumWeight) {
536    checkState(
537        this.maximumWeight == UNSET_INT,
538        "maximum weight was already set to %s",
539        this.maximumWeight);
540    checkState(
541        this.maximumSize == UNSET_INT, "maximum size was already set to %s", this.maximumSize);
542    checkArgument(maximumWeight >= 0, "maximum weight must not be negative");
543    this.maximumWeight = maximumWeight;
544    return this;
545  }
546
547  /**
548   * Specifies the weigher to use in determining the weight of entries. Entry weight is taken into
549   * consideration by {@link #maximumWeight(long)} when determining which entries to evict, and use
550   * of this method requires a corresponding call to {@link #maximumWeight(long)} prior to calling
551   * {@link #build}. Weights are measured and recorded when entries are inserted into the cache, and
552   * are thus effectively static during the lifetime of a cache entry.
553   *
554   * <p>When the weight of an entry is zero it will not be considered for size-based eviction
555   * (though it still may be evicted by other means).
556   *
557   * <p><b>Important note:</b> Instead of returning <em>this</em> as a {@code CacheBuilder}
558   * instance, this method returns {@code CacheBuilder<K1, V1>}. From this point on, either the
559   * original reference or the returned reference may be used to complete configuration and build
560   * the cache, but only the "generic" one is type-safe. That is, it will properly prevent you from
561   * building caches whose key or value types are incompatible with the types accepted by the
562   * weigher already provided; the {@code CacheBuilder} type cannot do this. For best results,
563   * simply use the standard method-chaining idiom, as illustrated in the documentation at top,
564   * configuring a {@code CacheBuilder} and building your {@link Cache} all in a single statement.
565   *
566   * <p><b>Warning:</b> if you ignore the above advice, and use this {@code CacheBuilder} to build a
567   * cache whose key or value type is incompatible with the weigher, you will likely experience a
568   * {@link ClassCastException} at some <i>undefined</i> point in the future.
569   *
570   * @param weigher the weigher to use in calculating the weight of cache entries
571   * @return this {@code CacheBuilder} instance (for chaining)
572   * @throws IllegalStateException if a weigher was already set or {@link #maximumSize} was
573   *     previously called
574   * @since 11.0
575   */
576  @GwtIncompatible // To be supported
577  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
578  public <K1 extends K, V1 extends V> CacheBuilder<K1, V1> weigher(
579      Weigher<? super K1, ? super V1> weigher) {
580    checkState(this.weigher == null);
581    if (strictParsing) {
582      checkState(
583          this.maximumSize == UNSET_INT,
584          "weigher can not be combined with maximum size (%s provided)",
585          this.maximumSize);
586    }
587
588    // safely limiting the kinds of caches this can produce
589    @SuppressWarnings("unchecked")
590    CacheBuilder<K1, V1> me = (CacheBuilder<K1, V1>) this;
591    me.weigher = checkNotNull(weigher);
592    return me;
593  }
594
595  long getMaximumWeight() {
596    if (expireAfterWriteNanos == 0 || expireAfterAccessNanos == 0) {
597      return 0;
598    }
599    return (weigher == null) ? maximumSize : maximumWeight;
600  }
601
602  // Make a safe contravariant cast now so we don't have to do it over and over.
603  @SuppressWarnings("unchecked")
604  <K1 extends K, V1 extends V> Weigher<K1, V1> getWeigher() {
605    return (Weigher<K1, V1>) MoreObjects.firstNonNull(weigher, OneWeigher.INSTANCE);
606  }
607
608  /**
609   * Specifies that each key (not value) stored in the cache should be wrapped in a {@link
610   * WeakReference} (by default, strong references are used).
611   *
612   * <p><b>Warning:</b> when this method is used, the resulting cache will use identity ({@code ==})
613   * comparison to determine equality of keys. Its {@link Cache#asMap} view will therefore
614   * technically violate the {@link Map} specification (in the same way that {@link IdentityHashMap}
615   * does).
616   *
617   * <p>Entries with keys that have been garbage collected may be counted in {@link Cache#size}, but
618   * will never be visible to read or write operations; such entries are cleaned up as part of the
619   * routine maintenance described in the class javadoc.
620   *
621   * @return this {@code CacheBuilder} instance (for chaining)
622   * @throws IllegalStateException if the key strength was already set
623   */
624  @GwtIncompatible // java.lang.ref.WeakReference
625  @CanIgnoreReturnValue
626  public CacheBuilder<K, V> weakKeys() {
627    return setKeyStrength(Strength.WEAK);
628  }
629
630  @CanIgnoreReturnValue
631  CacheBuilder<K, V> setKeyStrength(Strength strength) {
632    checkState(keyStrength == null, "Key strength was already set to %s", keyStrength);
633    keyStrength = checkNotNull(strength);
634    return this;
635  }
636
637  Strength getKeyStrength() {
638    return MoreObjects.firstNonNull(keyStrength, Strength.STRONG);
639  }
640
641  /**
642   * Specifies that each value (not key) stored in the cache should be wrapped in a {@link
643   * WeakReference} (by default, strong references are used).
644   *
645   * <p>Weak values will be garbage collected once they are weakly reachable. This makes them a poor
646   * candidate for caching; consider {@link #softValues} instead.
647   *
648   * <p><b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==})
649   * comparison to determine equality of values.
650   *
651   * <p>Entries with values that have been garbage collected may be counted in {@link Cache#size},
652   * but will never be visible to read or write operations; such entries are cleaned up as part of
653   * the routine maintenance described in the class javadoc.
654   *
655   * @return this {@code CacheBuilder} instance (for chaining)
656   * @throws IllegalStateException if the value strength was already set
657   */
658  @GwtIncompatible // java.lang.ref.WeakReference
659  @CanIgnoreReturnValue
660  public CacheBuilder<K, V> weakValues() {
661    return setValueStrength(Strength.WEAK);
662  }
663
664  /**
665   * Specifies that each value (not key) stored in the cache should be wrapped in a {@link
666   * SoftReference} (by default, strong references are used). Softly-referenced objects will be
667   * garbage-collected in a <i>globally</i> least-recently-used manner, in response to memory
668   * demand.
669   *
670   * <p><b>Warning:</b> in most circumstances it is better to set a per-cache {@linkplain
671   * #maximumSize(long) maximum size} instead of using soft references. You should only use this
672   * method if you are well familiar with the practical consequences of soft references.
673   *
674   * <p><b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==})
675   * comparison to determine equality of values.
676   *
677   * <p>Entries with values that have been garbage collected may be counted in {@link Cache#size},
678   * but will never be visible to read or write operations; such entries are cleaned up as part of
679   * the routine maintenance described in the class javadoc.
680   *
681   * @return this {@code CacheBuilder} instance (for chaining)
682   * @throws IllegalStateException if the value strength was already set
683   */
684  @GwtIncompatible // java.lang.ref.SoftReference
685  @CanIgnoreReturnValue
686  public CacheBuilder<K, V> softValues() {
687    return setValueStrength(Strength.SOFT);
688  }
689
690  @CanIgnoreReturnValue
691  CacheBuilder<K, V> setValueStrength(Strength strength) {
692    checkState(valueStrength == null, "Value strength was already set to %s", valueStrength);
693    valueStrength = checkNotNull(strength);
694    return this;
695  }
696
697  Strength getValueStrength() {
698    return MoreObjects.firstNonNull(valueStrength, Strength.STRONG);
699  }
700
701  /**
702   * Specifies that each entry should be automatically removed from the cache once a fixed duration
703   * has elapsed after the entry's creation, or the most recent replacement of its value.
704   *
705   * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long)
706   * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be
707   * useful in testing, or to disable caching temporarily without a code change.
708   *
709   * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or
710   * write operations. Expired entries are cleaned up as part of the routine maintenance described
711   * in the class javadoc.
712   *
713   * @param duration the length of time after an entry is created that it should be automatically
714   *     removed
715   * @return this {@code CacheBuilder} instance (for chaining)
716   * @throws IllegalArgumentException if {@code duration} is negative
717   * @throws IllegalStateException if {@link #expireAfterWrite} was already set
718   * @throws ArithmeticException for durations greater than +/- approximately 292 years
719   * @since 25.0
720   */
721  @J2ObjCIncompatible
722  @GwtIncompatible // java.time.Duration
723  @SuppressWarnings("GoodTime") // java.time.Duration decomposition
724  @CanIgnoreReturnValue
725  public CacheBuilder<K, V> expireAfterWrite(java.time.Duration duration) {
726    return expireAfterWrite(toNanosSaturated(duration), TimeUnit.NANOSECONDS);
727  }
728
729  /**
730   * Specifies that each entry should be automatically removed from the cache once a fixed duration
731   * has elapsed after the entry's creation, or the most recent replacement of its value.
732   *
733   * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long)
734   * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be
735   * useful in testing, or to disable caching temporarily without a code change.
736   *
737   * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or
738   * write operations. Expired entries are cleaned up as part of the routine maintenance described
739   * in the class javadoc.
740   *
741   * <p>If you can represent the duration as a {@link java.time.Duration} (which should be preferred
742   * when feasible), use {@link #expireAfterWrite(Duration)} instead.
743   *
744   * @param duration the length of time after an entry is created that it should be automatically
745   *     removed
746   * @param unit the unit that {@code duration} is expressed in
747   * @return this {@code CacheBuilder} instance (for chaining)
748   * @throws IllegalArgumentException if {@code duration} is negative
749   * @throws IllegalStateException if {@link #expireAfterWrite} was already set
750   */
751  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
752  @CanIgnoreReturnValue
753  public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
754    checkState(
755        expireAfterWriteNanos == UNSET_INT,
756        "expireAfterWrite was already set to %s ns",
757        expireAfterWriteNanos);
758    checkArgument(duration >= 0, "duration cannot be negative: %s %s", duration, unit);
759    this.expireAfterWriteNanos = unit.toNanos(duration);
760    return this;
761  }
762
763  @SuppressWarnings("GoodTime") // nanos internally, should be Duration
764  long getExpireAfterWriteNanos() {
765    return (expireAfterWriteNanos == UNSET_INT) ? DEFAULT_EXPIRATION_NANOS : expireAfterWriteNanos;
766  }
767
768  /**
769   * Specifies that each entry should be automatically removed from the cache once a fixed duration
770   * has elapsed after the entry's creation, the most recent replacement of its value, or its last
771   * access. Access time is reset by all cache read and write operations (including {@code
772   * Cache.asMap().get(Object)} and {@code Cache.asMap().put(K, V)}), but not by {@code
773   * containsKey(Object)}, nor by operations on the collection-views of {@link Cache#asMap}}. So,
774   * for example, iterating through {@code Cache.asMap().entrySet()} does not reset access time for
775   * the entries you retrieve.
776   *
777   * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long)
778   * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be
779   * useful in testing, or to disable caching temporarily without a code change.
780   *
781   * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or
782   * write operations. Expired entries are cleaned up as part of the routine maintenance described
783   * in the class javadoc.
784   *
785   * @param duration the length of time after an entry is last accessed that it should be
786   *     automatically removed
787   * @return this {@code CacheBuilder} instance (for chaining)
788   * @throws IllegalArgumentException if {@code duration} is negative
789   * @throws IllegalStateException if {@link #expireAfterAccess} was already set
790   * @throws ArithmeticException for durations greater than +/- approximately 292 years
791   * @since 25.0
792   */
793  @J2ObjCIncompatible
794  @GwtIncompatible // java.time.Duration
795  @SuppressWarnings("GoodTime") // java.time.Duration decomposition
796  @CanIgnoreReturnValue
797  public CacheBuilder<K, V> expireAfterAccess(java.time.Duration duration) {
798    return expireAfterAccess(toNanosSaturated(duration), TimeUnit.NANOSECONDS);
799  }
800
801  /**
802   * Specifies that each entry should be automatically removed from the cache once a fixed duration
803   * has elapsed after the entry's creation, the most recent replacement of its value, or its last
804   * access. Access time is reset by all cache read and write operations (including {@code
805   * Cache.asMap().get(Object)} and {@code Cache.asMap().put(K, V)}), but not by {@code
806   * containsKey(Object)}, nor by operations on the collection-views of {@link Cache#asMap}. So, for
807   * example, iterating through {@code Cache.asMap().entrySet()} does not reset access time for the
808   * entries you retrieve.
809   *
810   * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long)
811   * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be
812   * useful in testing, or to disable caching temporarily without a code change.
813   *
814   * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or
815   * write operations. Expired entries are cleaned up as part of the routine maintenance described
816   * in the class javadoc.
817   *
818   * <p>If you can represent the duration as a {@link java.time.Duration} (which should be preferred
819   * when feasible), use {@link #expireAfterAccess(Duration)} instead.
820   *
821   * @param duration the length of time after an entry is last accessed that it should be
822   *     automatically removed
823   * @param unit the unit that {@code duration} is expressed in
824   * @return this {@code CacheBuilder} instance (for chaining)
825   * @throws IllegalArgumentException if {@code duration} is negative
826   * @throws IllegalStateException if {@link #expireAfterAccess} was already set
827   */
828  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
829  @CanIgnoreReturnValue
830  public CacheBuilder<K, V> expireAfterAccess(long duration, TimeUnit unit) {
831    checkState(
832        expireAfterAccessNanos == UNSET_INT,
833        "expireAfterAccess was already set to %s ns",
834        expireAfterAccessNanos);
835    checkArgument(duration >= 0, "duration cannot be negative: %s %s", duration, unit);
836    this.expireAfterAccessNanos = unit.toNanos(duration);
837    return this;
838  }
839
840  @SuppressWarnings("GoodTime") // nanos internally, should be Duration
841  long getExpireAfterAccessNanos() {
842    return (expireAfterAccessNanos == UNSET_INT)
843        ? DEFAULT_EXPIRATION_NANOS
844        : expireAfterAccessNanos;
845  }
846
847  /**
848   * Specifies that active entries are eligible for automatic refresh once a fixed duration has
849   * elapsed after the entry's creation, or the most recent replacement of its value. The semantics
850   * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link
851   * CacheLoader#reload}.
852   *
853   * <p>As the default implementation of {@link CacheLoader#reload} is synchronous, it is
854   * recommended that users of this method override {@link CacheLoader#reload} with an asynchronous
855   * implementation; otherwise refreshes will be performed during unrelated cache read and write
856   * operations.
857   *
858   * <p>Currently automatic refreshes are performed when the first stale request for an entry
859   * occurs. The request triggering refresh will make a synchronous call to {@link
860   * CacheLoader#reload}
861   * to obtain a future of the new value. If the returned future is already complete, it is returned
862   * immediately. Otherwise, the old value is returned.
863   *
864   * <p><b>Note:</b> <i>all exceptions thrown during refresh will be logged and then swallowed</i>.
865   *
866   * @param duration the length of time after an entry is created that it should be considered
867   *     stale, and thus eligible for refresh
868   * @return this {@code CacheBuilder} instance (for chaining)
869   * @throws IllegalArgumentException if {@code duration} is negative
870   * @throws IllegalStateException if {@link #refreshAfterWrite} was already set
871   * @throws ArithmeticException for durations greater than +/- approximately 292 years
872   * @since 25.0
873   */
874  @J2ObjCIncompatible
875  @GwtIncompatible // java.time.Duration
876  @SuppressWarnings("GoodTime") // java.time.Duration decomposition
877  @CanIgnoreReturnValue
878  public CacheBuilder<K, V> refreshAfterWrite(java.time.Duration duration) {
879    return refreshAfterWrite(toNanosSaturated(duration), TimeUnit.NANOSECONDS);
880  }
881
882  /**
883   * Specifies that active entries are eligible for automatic refresh once a fixed duration has
884   * elapsed after the entry's creation, or the most recent replacement of its value. The semantics
885   * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link
886   * CacheLoader#reload}.
887   *
888   * <p>As the default implementation of {@link CacheLoader#reload} is synchronous, it is
889   * recommended that users of this method override {@link CacheLoader#reload} with an asynchronous
890   * implementation; otherwise refreshes will be performed during unrelated cache read and write
891   * operations.
892   *
893   * <p>Currently automatic refreshes are performed when the first stale request for an entry
894   * occurs. The request triggering refresh will make a synchronous call to {@link
895   * CacheLoader#reload}
896   * and immediately return the new value if the returned future is complete, and the old value
897   * otherwise.
898   *
899   * <p><b>Note:</b> <i>all exceptions thrown during refresh will be logged and then swallowed</i>.
900   *
901   * <p>If you can represent the duration as a {@link java.time.Duration} (which should be preferred
902   * when feasible), use {@link #refreshAfterWrite(Duration)} instead.
903   *
904   * @param duration the length of time after an entry is created that it should be considered
905   *     stale, and thus eligible for refresh
906   * @param unit the unit that {@code duration} is expressed in
907   * @return this {@code CacheBuilder} instance (for chaining)
908   * @throws IllegalArgumentException if {@code duration} is negative
909   * @throws IllegalStateException if {@link #refreshAfterWrite} was already set
910   * @since 11.0
911   */
912  @GwtIncompatible // To be supported (synchronously).
913  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
914  @CanIgnoreReturnValue
915  public CacheBuilder<K, V> refreshAfterWrite(long duration, TimeUnit unit) {
916    checkNotNull(unit);
917    checkState(refreshNanos == UNSET_INT, "refresh was already set to %s ns", refreshNanos);
918    checkArgument(duration > 0, "duration must be positive: %s %s", duration, unit);
919    this.refreshNanos = unit.toNanos(duration);
920    return this;
921  }
922
923  @SuppressWarnings("GoodTime") // nanos internally, should be Duration
924  long getRefreshNanos() {
925    return (refreshNanos == UNSET_INT) ? DEFAULT_REFRESH_NANOS : refreshNanos;
926  }
927
928  /**
929   * Specifies a nanosecond-precision time source for this cache. By default, {@link
930   * System#nanoTime} is used.
931   *
932   * <p>The primary intent of this method is to facilitate testing of caches with a fake or mock
933   * time source.
934   *
935   * @return this {@code CacheBuilder} instance (for chaining)
936   * @throws IllegalStateException if a ticker was already set
937   */
938  @CanIgnoreReturnValue
939  public CacheBuilder<K, V> ticker(Ticker ticker) {
940    checkState(this.ticker == null);
941    this.ticker = checkNotNull(ticker);
942    return this;
943  }
944
945  Ticker getTicker(boolean recordsTime) {
946    if (ticker != null) {
947      return ticker;
948    }
949    return recordsTime ? Ticker.systemTicker() : NULL_TICKER;
950  }
951
952  /**
953   * Specifies a listener instance that caches should notify each time an entry is removed for any
954   * {@linkplain RemovalCause reason}. Each cache created by this builder will invoke this listener
955   * as part of the routine maintenance described in the class documentation above.
956   *
957   * <p><b>Warning:</b> after invoking this method, do not continue to use <i>this</i> cache builder
958   * reference; instead use the reference this method <i>returns</i>. At runtime, these point to the
959   * same instance, but only the returned reference has the correct generic type information to
960   * ensure type safety. For best results, use the standard method-chaining idiom illustrated in the
961   * class documentation above, configuring a builder and building your cache in a single statement.
962   * Failure to heed this advice can result in a {@link ClassCastException} being thrown by a cache
963   * operation at some <i>undefined</i> point in the future.
964   *
965   * <p><b>Warning:</b> any exception thrown by {@code listener} will <i>not</i> be propagated to
966   * the {@code Cache} user, only logged via a {@link Logger}.
967   *
968   * @return the cache builder reference that should be used instead of {@code this} for any
969   *     remaining configuration and cache building
970   * @return this {@code CacheBuilder} instance (for chaining)
971   * @throws IllegalStateException if a removal listener was already set
972   */
973  public <K1 extends K, V1 extends V> CacheBuilder<K1, V1> removalListener(
974      RemovalListener<? super K1, ? super V1> listener) {
975    checkState(this.removalListener == null);
976
977    // safely limiting the kinds of caches this can produce
978    @SuppressWarnings("unchecked")
979    CacheBuilder<K1, V1> me = (CacheBuilder<K1, V1>) this;
980    me.removalListener = checkNotNull(listener);
981    return me;
982  }
983
984  // Make a safe contravariant cast now so we don't have to do it over and over.
985  @SuppressWarnings("unchecked")
986  <K1 extends K, V1 extends V> RemovalListener<K1, V1> getRemovalListener() {
987    return (RemovalListener<K1, V1>)
988        MoreObjects.firstNonNull(removalListener, NullListener.INSTANCE);
989  }
990
991  /**
992   * Enable the accumulation of {@link CacheStats} during the operation of the cache. Without this
993   * {@link Cache#stats} will return zero for all statistics. Note that recording stats requires
994   * bookkeeping to be performed with each operation, and thus imposes a performance penalty on
995   * cache operation.
996   *
997   * @return this {@code CacheBuilder} instance (for chaining)
998   * @since 12.0 (previously, stats collection was automatic)
999   */
1000  @CanIgnoreReturnValue
1001  public CacheBuilder<K, V> recordStats() {
1002    statsCounterSupplier = CACHE_STATS_COUNTER;
1003    return this;
1004  }
1005
1006  boolean isRecordingStats() {
1007    return statsCounterSupplier == CACHE_STATS_COUNTER;
1008  }
1009
1010  Supplier<? extends StatsCounter> getStatsCounterSupplier() {
1011    return statsCounterSupplier;
1012  }
1013
1014  /**
1015   * Builds a cache, which either returns an already-loaded value for a given key or atomically
1016   * computes or retrieves it using the supplied {@code CacheLoader}. If another thread is currently
1017   * loading the value for this key, simply waits for that thread to finish and returns its loaded
1018   * value. Note that multiple threads can concurrently load values for distinct keys.
1019   *
1020   * <p>This method does not alter the state of this {@code CacheBuilder} instance, so it can be
1021   * invoked again to create multiple independent caches.
1022   *
1023   * @param loader the cache loader used to obtain new values
1024   * @return a cache having the requested features
1025   */
1026  public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
1027      CacheLoader<? super K1, V1> loader) {
1028    checkWeightWithWeigher();
1029    return new LocalCache.LocalLoadingCache<>(this, loader);
1030  }
1031
1032  /**
1033   * Builds a cache which does not automatically load values when keys are requested.
1034   *
1035   * <p>Consider {@link #build(CacheLoader)} instead, if it is feasible to implement a {@code
1036   * CacheLoader}.
1037   *
1038   * <p>This method does not alter the state of this {@code CacheBuilder} instance, so it can be
1039   * invoked again to create multiple independent caches.
1040   *
1041   * @return a cache having the requested features
1042   * @since 11.0
1043   */
1044  public <K1 extends K, V1 extends V> Cache<K1, V1> build() {
1045    checkWeightWithWeigher();
1046    checkNonLoadingCache();
1047    return new LocalCache.LocalManualCache<>(this);
1048  }
1049
1050  private void checkNonLoadingCache() {
1051    checkState(refreshNanos == UNSET_INT, "refreshAfterWrite requires a LoadingCache");
1052  }
1053
1054  private void checkWeightWithWeigher() {
1055    if (weigher == null) {
1056      checkState(maximumWeight == UNSET_INT, "maximumWeight requires weigher");
1057    } else {
1058      if (strictParsing) {
1059        checkState(maximumWeight != UNSET_INT, "weigher requires maximumWeight");
1060      } else {
1061        if (maximumWeight == UNSET_INT) {
1062          LoggerHolder.logger.log(
1063              Level.WARNING, "ignoring weigher specified without maximumWeight");
1064        }
1065      }
1066    }
1067  }
1068
1069  /**
1070   * Returns a string representation for this CacheBuilder instance. The exact form of the returned
1071   * string is not specified.
1072   */
1073  @Override
1074  public String toString() {
1075    MoreObjects.ToStringHelper s = MoreObjects.toStringHelper(this);
1076    if (initialCapacity != UNSET_INT) {
1077      s.add("initialCapacity", initialCapacity);
1078    }
1079    if (concurrencyLevel != UNSET_INT) {
1080      s.add("concurrencyLevel", concurrencyLevel);
1081    }
1082    if (maximumSize != UNSET_INT) {
1083      s.add("maximumSize", maximumSize);
1084    }
1085    if (maximumWeight != UNSET_INT) {
1086      s.add("maximumWeight", maximumWeight);
1087    }
1088    if (expireAfterWriteNanos != UNSET_INT) {
1089      s.add("expireAfterWrite", expireAfterWriteNanos + "ns");
1090    }
1091    if (expireAfterAccessNanos != UNSET_INT) {
1092      s.add("expireAfterAccess", expireAfterAccessNanos + "ns");
1093    }
1094    if (keyStrength != null) {
1095      s.add("keyStrength", Ascii.toLowerCase(keyStrength.toString()));
1096    }
1097    if (valueStrength != null) {
1098      s.add("valueStrength", Ascii.toLowerCase(valueStrength.toString()));
1099    }
1100    if (keyEquivalence != null) {
1101      s.addValue("keyEquivalence");
1102    }
1103    if (valueEquivalence != null) {
1104      s.addValue("valueEquivalence");
1105    }
1106    if (removalListener != null) {
1107      s.addValue("removalListener");
1108    }
1109    return s.toString();
1110  }
1111
1112  /**
1113   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
1114   *
1115   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
1116   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
1117   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
1118   */
1119  @GwtIncompatible // java.time.Duration
1120  @SuppressWarnings("GoodTime") // duration decomposition
1121  private static long toNanosSaturated(java.time.Duration duration) {
1122    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
1123    // durations longer than approximately +/- 292 years).
1124    try {
1125      return duration.toNanos();
1126    } catch (ArithmeticException tooBig) {
1127      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
1128    }
1129  }
1130}