/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.asset.cache;
import com.jme3.asset.AssetKey;
import com.jme3.asset.AssetProcessor;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* A garbage collector bound asset cache that handles non-clonable objects.
* This cache assumes that the asset given to the user is the same asset
* that has been stored in the cache, in other words,
* {@link AssetProcessor#createClone(java.lang.Object) } for that asset
* returns the same object as the argument.
* This implementation will remove the asset from the cache
* once the asset is no longer referenced in user code and memory is low,
* e.g. the VM feels like purging the weak references for that asset.
*
* @author Kirill Vainer
*/
public class WeakRefAssetCache implements AssetCache {
private static final Logger logger = Logger.getLogger(WeakRefAssetCache.class.getName());
private final ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();
private final ConcurrentHashMap<AssetKey, AssetRef> assetCache
= new ConcurrentHashMap<AssetKey, AssetRef>();
private static class AssetRef extends WeakReference<Object> {
private final AssetKey assetKey;
public AssetRef(AssetKey assetKey, Object originalAsset, ReferenceQueue<Object> refQueue){
super(originalAsset, refQueue);
this.assetKey = assetKey;
}
}
private void removeCollectedAssets(){
int removedAssets = 0;
for (AssetRef ref; (ref = (AssetRef)refQueue.poll()) != null;){
// Asset was collected, note that at this point the asset cache
// might not even have this asset anymore, it is OK.
if (assetCache.remove(ref.assetKey) != null){
removedAssets ++;
}
}
if (removedAssets >= 1) {
logger.log(Level.FINE, "WeakRefAssetCache: {0} assets were purged from the cache.", removedAssets);
}
}
public <T> void addToCache(AssetKey<T> key, T obj) {
removeCollectedAssets();
// NOTE: Some thread issues can hapen if another
// thread is loading an asset with the same key ..
AssetRef ref = new AssetRef(key, obj, refQueue);
assetCache.put(key, ref);
}
public <T> T getFromCache(AssetKey<T> key) {
AssetRef ref = assetCache.get(key);
if (ref != null){
return (T) ref.get();
}else{
return null;
}
}
public boolean deleteFromCache(AssetKey key) {
return assetCache.remove(key) != null;
}
public void clearCache() {
assetCache.clear();
}
public <T> void registerAssetClone(AssetKey<T> key, T clone) {
}
public void notifyNoAssetClone() {
}
}