Module ojalgo
Package org.ojalgo.type

Class ForgetfulMap<K,​V>

  • All Implemented Interfaces:
    java.util.Map<K,​V>
    public final class ForgetfulMap<K,​V>
extends java.util.AbstractMap<K,​V>
    A Map that can forget entries after a specified period of time – a cache in other words. The entries can either expire after a certain amount of time has passed since they were created/written or since they were last accessed.

    In addition to implementing the Map interface, also looked at the Cache interface of the Caffeine library, and mimicked some of its methods.

    Furthermore, this class provides a re-implementation of TypeCache.

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      static class  ForgetfulMap.Builder  
      private static class  ForgetfulMap.CachedValue<V>
      Helper class to store value and timestamps
      static interface  ForgetfulMap.ValueCache<V>
      The specifications of TypeCache to allow for another implementation.
      private static class  ForgetfulMap.ValueCacheImpl<K,​V>
      A re-implementation of TypeCache backed by a ForgetfulMap.

      • Nested classes/interfaces inherited from class java.util.AbstractMap

        java.util.AbstractMap.SimpleEntry<K extends java.lang.Object,​V extends java.lang.Object>, java.util.AbstractMap.SimpleImmutableEntry<K extends java.lang.Object,​V extends java.lang.Object>

      • Nested classes/interfaces inherited from interface java.util.Map

        java.util.Map.Entry<K extends java.lang.Object,​V extends java.lang.Object>

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void cleanUp()
      Removes all entries that have expired.
      void clear()  
      boolean containsKey​(java.lang.Object key)  
      boolean containsValue​(java.lang.Object value)  
      java.util.Set<java.util.Map.Entry<K,​V>> entrySet()  
      boolean equals​(java.lang.Object obj)  
      long estimatedSize()
      Returns the approximate number of entries in this cache.
      V get​(java.lang.Object key)  
      V get​(K key, java.util.function.Function<? super K,​? extends V> mappingFunction)
      Returns the value associated with the key in this cache, obtaining that value from the mappingFunction if necessary.
      java.util.Map<K,​V> getAllPresent​(java.lang.Iterable<? extends K> keys)
      Returns a map of the values associated with the keys in this cache.
      V getIfPresent​(K key)
      Returns the value associated with the key in this cache, or null if there is no cached value for the key.
      int hashCode()  
      void invalidate​(K key)
      Discards any cached value for the key.
      void invalidateAll()
      Discards all entries in the cache.
      void invalidateAll​(java.lang.Iterable<? extends K> keys)
      Discards any cached values for the keys.
      boolean isEmpty()  
      private boolean isExpired​(long now, ForgetfulMap.CachedValue<V> cached)  
      java.util.Set<K> keySet()  
      static ForgetfulMap.Builder newBuilder()  
      ForgetfulMap.ValueCache<V> newValueCache​(K key, java.util.function.Function<? super K,​? extends V> valueSupplier)  
      V put​(K key, V value)  
      void putAll​(java.util.Map<? extends K,​? extends V> map)
      Copies all of the mappings from the specified map to the cache.
      V remove​(java.lang.Object key)  
      boolean remove​(java.lang.Object key, java.lang.Object value)  
      int size()  
      private java.util.Map.Entry<K,​V> unwrap​(java.util.Map.Entry<K,​ForgetfulMap.CachedValue<V>> entry)  

      • Methods inherited from class java.util.AbstractMap

        clone, toString, values

      • Methods inherited from class java.lang.Object

        finalize, getClass, notify, notifyAll, wait, wait, wait

      • Methods inherited from interface java.util.Map

        compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, replace, replace, replaceAll

    • Field Detail

      • CLEANER

        private static final java.util.concurrent.ScheduledExecutorService CLEANER

      • myAccessLimit

        private final long myAccessLimit

      • myDisposer

        private final java.util.function.Consumer<V> myDisposer

      • myWriteLimit

        private final long myWriteLimit

    • Method Detail

      • cleanUp

        public void cleanUp()
        Removes all entries that have expired. This method is automatically called at regular intervals, but can also be called manually to remove entries that have expired since the last cleanup.

      • clear

        public void clear()
        Specified by:
        clear in interface java.util.Map<K,​V>
        Overrides:
        clear in class java.util.AbstractMap<K,​V>

      • containsKey

        public boolean containsKey​(java.lang.Object key)
        Specified by:
        containsKey in interface java.util.Map<K,​V>
        Overrides:
        containsKey in class java.util.AbstractMap<K,​V>

      • containsValue

        public boolean containsValue​(java.lang.Object value)
        Specified by:
        containsValue in interface java.util.Map<K,​V>
        Overrides:
        containsValue in class java.util.AbstractMap<K,​V>

      • entrySet

        public java.util.Set<java.util.Map.Entry<K,​V>> entrySet()
        Specified by:
        entrySet in interface java.util.Map<K,​V>
        Specified by:
        entrySet in class java.util.AbstractMap<K,​V>

      • equals

        public boolean equals​(java.lang.Object obj)
        Specified by:
        equals in interface java.util.Map<K,​V>
        Overrides:
        equals in class java.util.AbstractMap<K,​V>

      • estimatedSize

        public long estimatedSize()
        Returns the approximate number of entries in this cache. The value returned is an estimate; the actual count may differ if there are concurrent insertions or removals, or if some entries are pending removal due to expiration or weak/soft reference collection. In the case of stale entries this inaccuracy can be mitigated by performing a cleanUp() first.

      • get

        public V get​(K key,
             java.util.function.Function<? super K,​? extends V> mappingFunction)
        Returns the value associated with the key in this cache, obtaining that value from the mappingFunction if necessary. This method provides a simple substitute for the conventional "if cached, return; otherwise create, cache and return" pattern.

        If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this cache unless null. The entire method invocation is performed atomically, so the function is applied at most once per key. Some attempted update operations on this cache by other threads may be blocked while the computation is in progress, so the computation should be short and simple, and must not attempt to update any other mappings of this cache.

      • get

        public V get​(java.lang.Object key)
        Specified by:
        get in interface java.util.Map<K,​V>
        Overrides:
        get in class java.util.AbstractMap<K,​V>

      • getAllPresent

        public java.util.Map<K,​V> getAllPresent​(java.lang.Iterable<? extends K> keys)
        Returns a map of the values associated with the keys in this cache. The returned map will only contain entries which are already present in the cache.

        Note that duplicate elements in keys, as determined by Object.equals(java.lang.Object), will be ignored.

      • getIfPresent

        public V getIfPresent​(K key)
        Returns the value associated with the key in this cache, or null if there is no cached value for the key.

      • hashCode

        public int hashCode()
        Specified by:
        hashCode in interface java.util.Map<K,​V>
        Overrides:
        hashCode in class java.util.AbstractMap<K,​V>

      • invalidate

        public void invalidate​(K key)
        Discards any cached value for the key. The behavior of this operation is undefined for an entry that is being loaded (or reloaded) and is otherwise not present.

      • invalidateAll

        public void invalidateAll()
        Discards all entries in the cache. The behavior of this operation is undefined for an entry that is being loaded (or reloaded) and is otherwise not present.

      • invalidateAll

        public void invalidateAll​(java.lang.Iterable<? extends K> keys)
        Discards any cached values for the keys. The behavior of this operation is undefined for an entry that is being loaded (or reloaded) and is otherwise not present.

      • isEmpty

        public boolean isEmpty()
        Specified by:
        isEmpty in interface java.util.Map<K,​V>
        Overrides:
        isEmpty in class java.util.AbstractMap<K,​V>

      • keySet

        public java.util.Set<K> keySet()
        Specified by:
        keySet in interface java.util.Map<K,​V>
        Overrides:
        keySet in class java.util.AbstractMap<K,​V>

      • newValueCache

        public ForgetfulMap.ValueCache<V> newValueCache​(K key,
                                                java.util.function.Function<? super K,​? extends V> valueSupplier)

      • put

        public V put​(K key,
             V value)
        Specified by:
        put in interface java.util.Map<K,​V>
        Overrides:
        put in class java.util.AbstractMap<K,​V>

      • putAll

        public void putAll​(java.util.Map<? extends K,​? extends V> map)
        Copies all of the mappings from the specified map to the cache. The effect of this call is equivalent to that of calling put(k, v) on this map once for each mapping from key k to value v in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.
        Specified by:
        putAll in interface java.util.Map<K,​V>
        Overrides:
        putAll in class java.util.AbstractMap<K,​V>

      • remove

        public V remove​(java.lang.Object key)
        Specified by:
        remove in interface java.util.Map<K,​V>
        Overrides:
        remove in class java.util.AbstractMap<K,​V>

      • remove

        public boolean remove​(java.lang.Object key,
                      java.lang.Object value)

      • size

        public int size()
        Specified by:
        size in interface java.util.Map<K,​V>
        Overrides:
        size in class java.util.AbstractMap<K,​V>