Class DelegatingNullSafeBaseCache<K,​V>

    • Constructor Detail

      • DelegatingNullSafeBaseCache

        public DelegatingNullSafeBaseCache()
    • Method Detail

      • delegate

        protected abstract BaseCache<K,​V> delegate()
        Specified by:
        delegate in class com.google.common.collect.ForwardingObject
      • evict

        public void evict​(K key)
        Description copied from interface: BaseCache
        Evict an entry from the cache. If the cache does not currently contain an entry under this key, then this is ignored. If it does, that entry is evicted, to be re-calculated on the next get.

        Use CacheManager.evictAll() to evict all entries of the entire cache.

        Specified by:
        evict in interface BaseCache<K,​V>
      • put

        public void put​(K key,
                        V value)
        Description copied from interface: BaseCache
        Puts a new entry into the Cache, replacing any existing one.

        Normally, you often never need to call this method, as in regular usage scenarios a cache API client just invokes Cache.get(Object) (or CheckedCache.get(Object), which then internally (may) use the CacheFunction (or CheckedCacheFunction) - without you ever having had to explicitly put something into the Cache.

        This method is ONLY (!) intended for "optimizations". It is useful if the code using a cache already has a key and value (e.g. following an external update notification event kind of thing) and wants to "save time" on an expected subsequent Cache.get(Object) (or CheckedCache.get(Object) invoking the CacheFunction (or CheckedCacheFunction) unnecessarily, using this "hint" to "propose" an entry to the cache.

        Any code using this must expect key/value pairs that have been put into a cache to disappear at any time (e.g. when the cache is full and this key/value hasn't been used, or after a programmatic or end-user operator initiated eviction), and be able to obtain THE SAME value from the CacheFunction (or CheckedCacheFunction), for the given key.

        Failure to implement calls to this put method consistent with the implementation of the cache's get function WILL lead to weird cache inconsistencies!

        Some Cache implementations may IGNORE this "hint" method.

        Specified by:
        put in interface BaseCache<K,​V>
        Parameters:
        key - the key of the proposed new cache entry
        value - the value of the proposed new cache entry
      • asMap

        public Map<K,​V> asMap()
        Description copied from interface: BaseCache
        Returns a view of the entries stored in this cache as an immutable map.
        Specified by:
        asMap in interface BaseCache<K,​V>
      • checkNonNullKeys

        protected static <K> Iterable<K> checkNonNullKeys​(@Nullable Iterable<K> keys)
      • checkReturnValue

        protected static <K,​V> V checkReturnValue​(K key,
                                                        @Nullable V value)
      • checkReturnValue

        protected static <K,​V> com.google.common.collect.ImmutableMap<K,​V> checkReturnValue​(@Nullable com.google.common.collect.ImmutableMap<K,​V> map)