FileCacheARC (NetCDF-Java All API v5.9.1)

java.lang.Object
- ucar.nc2.util.cache.FileCacheARC

All Implemented Interfaces:: FileCacheIF

@ThreadSafe
public class FileCacheARC
extends java.lang.Object
implements FileCacheIF

ARC cach algorithm not complete.

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.concurrent.ConcurrentHashMap<java.lang.Object,ucar.nc2.util.cache.FileCacheARC.CacheElement>`	`cache`
`protected static org.slf4j.Logger`	`cacheLog`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.Integer,ucar.nc2.util.cache.FileCacheARC.CacheElement.CacheFile>`	`files`
`protected int`	`hardLimit`
`protected java.util.concurrent.atomic.AtomicInteger`	`hits`
`protected static org.slf4j.Logger`	`log`
`protected int`	`minElements`
`protected java.util.concurrent.atomic.AtomicInteger`	`miss`
`protected java.lang.String`	`name`
`protected int`	`period`
`protected java.util.concurrent.ConcurrentSkipListMap<ucar.nc2.util.cache.FileCacheARC.CacheElement,ucar.nc2.util.cache.FileCacheARC.CacheElement>`	`shadowCache`
`protected int`	`softLimit`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.Object,ucar.nc2.util.cache.FileCacheARC.Tracker>`	`track`

Constructor Summary

Constructors
Constructor and Description
`FileCacheARC(java.lang.String name, int minElementsInMemory, int softLimit, int hardLimit, int period)` Constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FileCacheable`	`acquire(FileFactory factory, DatasetUrl location)` Acquire a FileCacheable, and lock it so no one else can use it.
`FileCacheable`	`acquire(FileFactory factory, java.lang.Object hashKey, DatasetUrl location, int buffer_size, CancelTask cancelTask, java.lang.Object spiObject)` Acquire a FileCacheable from the cache, and lock it so no one else can use it.
`void`	`clearCache(boolean force)` Remove all cache entries.
`void`	`disable()` Disable the cache, and force release all files.
`void`	`eject(java.lang.Object hashKey)` LOOK copied from FileCache, probably wrong Remove all instances of object from the cache
`void`	`enable()` Enable the cache, with the current set of parameters.
`java.lang.String`	`getInfo(FileCacheable ncfile)`
`boolean`	`release(FileCacheable ncfile)` Release the file.
`void`	`resetTracking()`
`java.util.List<java.lang.String>`	`showCache()`
`void`	`showCache(java.util.Formatter format)` Show individual cache entries, add to formatter.
`void`	`showStats(java.util.Formatter format)` Add stat report (hits, misses, etc) to formatter.
`void`	`showTracking(java.util.Formatter format)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - log
```
protected static final org.slf4j.Logger log
```
  - cacheLog
```
protected static final org.slf4j.Logger cacheLog
```
  - name
```
protected java.lang.String name
```
  - softLimit
```
protected final int softLimit
```
  - minElements
```
protected final int minElements
```
  - hardLimit
```
protected final int hardLimit
```
  - period
```
protected final int period
```
  - shadowCache
```
protected final java.util.concurrent.ConcurrentSkipListMap<ucar.nc2.util.cache.FileCacheARC.CacheElement,ucar.nc2.util.cache.FileCacheARC.CacheElement> shadowCache
```
  - cache
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.Object,ucar.nc2.util.cache.FileCacheARC.CacheElement> cache
```
  - files
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.Integer,ucar.nc2.util.cache.FileCacheARC.CacheElement.CacheFile> files
```
  - hits
```
protected final java.util.concurrent.atomic.AtomicInteger hits
```
  - miss
```
protected final java.util.concurrent.atomic.AtomicInteger miss
```
  - track
```
protected java.util.concurrent.ConcurrentHashMap<java.lang.Object,ucar.nc2.util.cache.FileCacheARC.Tracker> track
```
- Constructor Detail
  - FileCacheARC
```
public FileCacheARC(java.lang.String name,
                    int minElementsInMemory,
                    int softLimit,
                    int hardLimit,
                    int period)
```
    Constructor.
    
    Parameters:
    
    name - of file cache
    
    minElementsInMemory - keep this number in the cache
    
    softLimit - trigger a cleanup if it goes over this number.
    
    hardLimit - if > 0, never allow more than this many elements. This causes a cleanup to be done in the calling thread.
    
    period - if > 0, do periodic cleanups every this number of seconds.
- Method Detail
  - disable
```
public void disable()
```
    Disable the cache, and force release all files. You must still call shutdown() before exiting the application.
    
    Specified by:
    
    disable in interface FileCacheIF
  - enable
```
public void enable()
```
    Enable the cache, with the current set of parameters.
    
    Specified by:
    
    enable in interface FileCacheIF
  - acquire
```
public FileCacheable acquire(FileFactory factory,
                             DatasetUrl location)
                      throws java.io.IOException
```
    Acquire a FileCacheable, and lock it so no one else can use it. call FileCacheable.close() when done.
    
    Specified by:
    
    acquire in interface FileCacheIF
    
    Parameters:
    
    factory - use this factory to open the file; may not be null
    
    location - file location, also used as the cache name, will be passed to the NetcdfFileFactory
    
    Returns:
    
    NetcdfFile corresponding to location.
    
    Throws:
    
    java.io.IOException - on error
  - acquire
```
public FileCacheable acquire(FileFactory factory,
                             java.lang.Object hashKey,
                             DatasetUrl location,
                             int buffer_size,
                             CancelTask cancelTask,
                             java.lang.Object spiObject)
                      throws java.io.IOException
```
    Acquire a FileCacheable from the cache, and lock it so no one else can use it. If not already in cache, open it with FileFactory, and put in cache.
    Call FileCacheable.close() when done, (rather than FileCacheIF.release() directly) and the file is then released instead of closed.
    If cache size goes over maxElement, then immediately (actually in 100 msec) schedule a cleanup in a background thread. This means that the cache should never get much larger than maxElement, unless you have them all locked.
    
    Specified by:
    
    acquire in interface FileCacheIF
    
    Parameters:
    
    factory - use this factory to open the file if not in the cache; may not be null
    
    hashKey - unique key for this file. If null, the location will be used
    
    location - file location, may also used as the cache name, will be passed to the NetcdfFileFactory
    
    buffer_size - RandomAccessFile buffer size, if <= 0, use default size
    
    cancelTask - user can cancel, ok to be null.
    
    spiObject - sent to iosp.setSpecial() if not null
    
    Returns:
    
    FileCacheable corresponding to location.
    
    Throws:
    
    java.io.IOException - on error
  - eject
```
public void eject(java.lang.Object hashKey)
```
    LOOK copied from FileCache, probably wrong Remove all instances of object from the cache
    
    Specified by:
    
    eject in interface FileCacheIF
    
    Parameters:
    
    hashKey - the object
  - release
```
public boolean release(FileCacheable ncfile)
                throws java.io.IOException
```
    Release the file. This unlocks it, updates its lastAccessed date. FileCacheable.close() needs to call this instead of actually closing.
    
    Specified by:
    
    release in interface FileCacheIF
    
    Parameters:
    
    ncfile - release the lock on this FileCacheable object.
    
    Throws:
    
    java.io.IOException - if file not in cache.
  - getInfo
```
public java.lang.String getInfo(FileCacheable ncfile)
```
  - clearCache
```
public void clearCache(boolean force)
```
    Remove all cache entries.
    
    Specified by:
    
    clearCache in interface FileCacheIF
    
    Parameters:
    
    force - if true, remove them even if they are currently locked.
  - showCache
```
public void showCache(java.util.Formatter format)
```
    Show individual cache entries, add to formatter.
    
    Specified by:
    
    showCache in interface FileCacheIF
    
    Parameters:
    
    format - add to this
  - showCache
```
public java.util.List<java.lang.String> showCache()
```
    Specified by:
    
    showCache in interface FileCacheIF
  - showStats
```
public void showStats(java.util.Formatter format)
```
    Add stat report (hits, misses, etc) to formatter.
    
    Specified by:
    
    showStats in interface FileCacheIF
    
    Parameters:
    
    format - add to this
  - showTracking
```
public void showTracking(java.util.Formatter format)
```
    Specified by:
    
    showTracking in interface FileCacheIF
  - resetTracking
```
public void resetTracking()
```
    Specified by:
    
    resetTracking in interface FileCacheIF

Class FileCacheARC

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

cacheLog

name

softLimit

minElements

hardLimit

period

shadowCache

cache

files

hits

miss

track

Constructor Detail

FileCacheARC

Method Detail

disable

enable

acquire

acquire

eject

release

getInfo

clearCache

showCache

showCache

showStats

showTracking

resetTracking