/*******************************************************************************
* Copyright (c) 2006 Oracle Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Cameron Bateman/Oracle - initial API and implementation
*
********************************************************************************/
package org.eclipse.jst.jsf.designtime.internal.symbols;
import java.io.IOException;
import java.io.InputStream;
import java.util.AbstractMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.jsf.common.internal.resource.EventResult;
import org.eclipse.jst.jsf.common.internal.resource.IResourceLifecycleListener;
import org.eclipse.jst.jsf.common.internal.resource.LifecycleListener;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.EventType;
import org.eclipse.jst.jsf.context.symbol.internal.impl.IMapSourceInfo;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.tld.LoadBundleUtil;
class ResourceBundleMapSource extends AbstractMap implements IMapSourceInfo
{
private static final String PROPERTY_QUALIFIER =
"org.eclipse.jst.jsf.designtime.internal.jsp"; //$NON-NLS-1$
private static final String SESSION_PROPERTY_NAME_PROJECT =
"ResourceBundleMapSource"; //$NON-NLS-1$
private static final QualifiedName SESSION_PROPERTY_KEY_PROJECT =
new QualifiedName(PROPERTY_QUALIFIER, SESSION_PROPERTY_NAME_PROJECT);
private static final Object STATIC_LOCK = new Object();
private static IFile getCachedBundleFile(final IProject project, final String baseName)
{
if (project != null)
{
final Map<String, BundleFileCacheInfo> bundleFileCache = getBundleFileCache(project);
if (bundleFileCache != null)
{
final BundleFileCacheInfo info = bundleFileCache.get(baseName);
if (info != null)
{
return info.getFile();
}
}
}
return null;
}
private static class BundleFileCacheInfo
{
private final IFile _file;
private final Map<Object,CachedDataItem> _cachedData;
public BundleFileCacheInfo(final IFile file)
{
super();
_file = file;
_cachedData =
Collections.synchronizedMap(new HashMap<Object, CachedDataItem>());
}
public IFile getFile()
{
return _file;
}
public Object getCachedData(final Object key)
{
CachedDataItem item = _cachedData.get(key);
if (item != null)
{
return item.getData();
}
return null;
}
public Object putCachedData(final Object key, final Object value, final long timestamp)
{
CachedDataItem item = new CachedDataItem(value, timestamp);
CachedDataItem oldItem = _cachedData.put(key, item);
if (oldItem != null)
{
return oldItem.getData();
}
return null;
}
public boolean hasChanged(final Object key, final long timestamp)
{
CachedDataItem item = _cachedData.get(key);
if (item != null)
{
return item.getTimestamp() != timestamp;
}
return false;
}
private static class CachedDataItem
{
private final Object _data;
private final long _timestamp;
public CachedDataItem(Object data, long timestamp)
{
super();
_data = data;
_timestamp = timestamp;
}
public final Object getData()
{
return _data;
}
public final long getTimestamp()
{
return _timestamp;
}
}
}
private static Map<String, BundleFileCacheInfo> getBundleFileCache(final IProject project)
{
synchronized(STATIC_LOCK)
{
Map<String, BundleFileCacheInfo> bundleFileCache = null;
try
{
bundleFileCache =
(Map<String, BundleFileCacheInfo>) project.getSessionProperty(SESSION_PROPERTY_KEY_PROJECT);
if (bundleFileCache == null)
{
bundleFileCache = new HashMap<String, BundleFileCacheInfo>();
final LifecycleListener listener = new LifecycleListener(project, ResourcesPlugin.getWorkspace());
listener.addListener(new IResourceLifecycleListener()
{
public EventResult acceptEvent(final ResourceLifecycleEvent event)
{
EventResult result = EventResult.getDefaultEventResult();
if (event.getEventType() == EventType.RESOURCE_INACCESSIBLE)
{
try
{
//Bug 283764: this listener may be called more than once - check project not already inaccessible
if (project.isAccessible())
{
final Map<String, BundleFileCacheInfo> bundleCache =
(Map<String, BundleFileCacheInfo>) project.getSessionProperty(SESSION_PROPERTY_KEY_PROJECT);
//This listener may be called more than once - check session property not already nulled
if (bundleCache != null)
{
bundleCache.clear();
project.setSessionProperty(SESSION_PROPERTY_KEY_PROJECT, null);
}
}
}
catch (final CoreException ce)
{
JSFCorePlugin.log("Error clearing bundle file cache", ce); //$NON-NLS-1$
}
result = EventResult.getDisposeAfterEventResult();
}
return result;
}
}
);
project.setSessionProperty(SESSION_PROPERTY_KEY_PROJECT, bundleFileCache);
}
}
catch (final CoreException ce)
{
JSFCorePlugin.log("Error creating bundle file cache", ce); //$NON-NLS-1$
}
return bundleFileCache;
}
}
private static IFile createCachedBundleFile(final IProject project,
final String resourcePathStr)
throws IOException, CoreException
{
final IStorage storage =
LoadBundleUtil.getLoadBundleResource(project, resourcePathStr);
IFile bundleRes = null;
if (storage != null
&& storage.getAdapter(IFile.class) != null)
{
bundleRes = (IFile) storage.getAdapter(IFile.class);
// if file is removed, clear the bundle from the store.
final LifecycleListener listener = new LifecycleListener(bundleRes, ResourcesPlugin.getWorkspace());
listener.addListener(new IResourceLifecycleListener()
{
public EventResult acceptEvent(final ResourceLifecycleEvent event)
{
EventResult result = EventResult.getDefaultEventResult();
if (event.getEventType() == EventType.RESOURCE_INACCESSIBLE)
{
Map<String, BundleFileCacheInfo> bundleFileCache = getBundleFileCache(project);
bundleFileCache.remove(resourcePathStr);
result = EventResult.getDisposeAfterEventResult();
}
return result;
}
}
);
getBundleFileCache(project).put(resourcePathStr, new BundleFileCacheInfo(bundleRes));
return bundleRes;
}
throw new IOException("Bundle "+resourcePathStr+" not found in classpath for project: "+project.getName()); //$NON-NLS-1$ //$NON-NLS-2$
}
private Properties _resourceBundle; // = null; set on first access or changes
private final IFile _bundleFile; // the resource
private final String _resourcePathStr; // the key used in the file cache
// as returned by IResource.getModificationStamp()
// the last time _resourceBundle was loaded
private long _lastModificationStamp;
ResourceBundleMapSource(final IProject context,
final String resourcePathStr)
throws IOException, JavaModelException, CoreException
{
IFile cachedBundleFile = getCachedBundleFile(context, resourcePathStr);
if (cachedBundleFile == null)
{
cachedBundleFile = createCachedBundleFile(context, resourcePathStr);
}
_bundleFile = cachedBundleFile;
_resourcePathStr = resourcePathStr;
}
private void checkAndRefreshBundle()
{
if (_bundleFile.isAccessible())
{
if (_resourceBundle == null // doesn't exist yet
// exists but ws is out of sync
|| !_bundleFile.isSynchronized(IResource.DEPTH_ZERO)
// exists but user has changed in workspace
|| _bundleFile.getModificationStamp()
!= _lastModificationStamp)
{
InputStream bundleStream = null;
try
{
// force refresh if out of sync
bundleStream = _bundleFile.getContents(true);
_resourceBundle = new Properties();
_resourceBundle.load(bundleStream);
_lastModificationStamp = _bundleFile.getModificationStamp();
}
catch (final CoreException ce)
{
JSFCorePlugin.log("Error refreshing bundle", ce); //$NON-NLS-1$
}
catch (final IOException ioe)
{
JSFCorePlugin.log("Error refreshing bundle", ioe); //$NON-NLS-1$
}
finally
{
if (bundleStream != null)
{
try
{
bundleStream.close();
}
catch (final IOException ioe)
{
JSFCorePlugin.log("Error closing bundle", ioe); //$NON-NLS-1$
}
}
}
}
}
else
{
// bundle no longer exists so remove it
final Map<String, BundleFileCacheInfo> bundleFileCache = getBundleFileCache(_bundleFile.getProject());
if (bundleFileCache != null &&
bundleFileCache.containsKey(_resourcePathStr))
{
bundleFileCache.remove(_resourcePathStr);
}
// in either case, clear the bundle entry
if (_resourceBundle != null)
{
_resourceBundle.clear();
_resourceBundle = null;
}
}
}
@Override
public Set entrySet()
{
checkAndRefreshBundle();
if (_resourceBundle == null)
{
return Collections.EMPTY_SET;
}
return _resourceBundle.entrySet();
}
/**
* @param key
* @return the value
* @see java.util.AbstractMap#get(java.lang.Object)
* @overrride to optimize for the fact that we are doing a hash get
*/
//
@Override
public Object get(final Object key)
{
checkAndRefreshBundle();
if (_resourceBundle == null)
{
return null;
}
return _resourceBundle.get(key);
}
public final boolean hasChanged(final Object key)
{
final BundleFileCacheInfo cache = getBundleFileCache(
_bundleFile.getProject()).get(_resourcePathStr);
if (cache != null)
{
return cache.hasChanged(key, _bundleFile.getModificationStamp());
}
// return true since if there is nothing cached, the caller will want
// to react.
return true;
}
public Object getCachedValue(final Object key)
{
final BundleFileCacheInfo cache = getBundleFileCache(
_bundleFile.getProject()).get(_resourcePathStr);
if (cache != null)
{
return cache.getCachedData(key);
}
return null;
}
public void putCachedValue(final Object key, final Object value)
{
final BundleFileCacheInfo cache = getBundleFileCache(
_bundleFile.getProject()).get(_resourcePathStr);
if (cache != null)
{
cache.putCachedData(key, value, _lastModificationStamp);
}
}
}