/*******************************************************************************
* Copyright (c) 2001, 2008 Oracle Corporation and others.
* 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:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.common.internal.types;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.ElementChangedEvent;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IElementChangedListener;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaElementDelta;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.jsf.common.JSFCommonPlugin;
import org.eclipse.jst.jsf.context.symbol.IBeanMethodSymbol;
import org.eclipse.jst.jsf.context.symbol.IBeanPropertySymbol;
/**Provides a cache for java IType properties. It can cache bean property symbols, method symbols,
* supertypes and implemented interfaces per IType. The cache listens to changes in the java model
* and invalidates affected properties, but does not update them.
*
* @author Matthias
*/
public class TypeInfoCache implements IElementChangedListener {
private static TypeInfoCache instance = null;
/**Returns the TypeInfoCache instance. This instance is considered
* protected and must not be disposded with disposeInstance.
*
* @return the TypeInfoCache instance
*/
public static synchronized TypeInfoCache getInstance() {
if (instance == null) {
instance = createNewInstance();
}
return instance;
}
/**
* Create a new instance of the type cache.
*
* @return a new instance of the type info cache.
*/
public static TypeInfoCache createNewInstance()
{
final TypeInfoCache newCache = new TypeInfoCache();
JavaCore.addElementChangedListener(newCache, ElementChangedEvent.POST_CHANGE);
return newCache;
}
/**
* If cache is not the singleton instance acquired with {@link #getInstance()}
* then the cache will be disposed and should not be used. If cache is
* protected instance, then nothing will happen (the singleton instance
* cannot be disposed).
*
* @param cache
*/
public static void disposeInstance(final TypeInfoCache cache)
{
if (cache != null
&& cache != instance)
{
JavaCore.removeElementChangedListener(cache);
synchronized(cache)
{
if (cache.cachedInfo != null)
{
cache.cachedInfo.clear();
}
if (cache.cachedTypesByAffectingTypeRoot != null)
{
cache.cachedTypesByAffectingTypeRoot.clear();
}
if (cache.cachedTypesByMissingSupertypename != null)
{
cache.cachedTypesByMissingSupertypename.clear();
}
}
}
}
private final Map<IType, TypeInfo> cachedInfo;
private final Map<ITypeRoot, Set<IType>> cachedTypesByAffectingTypeRoot;
private final Map<String, Set<IType>> cachedTypesByMissingSupertypename;
private TypeInfoCache() {
cachedInfo = new HashMap<IType, TypeInfo>();
cachedTypesByAffectingTypeRoot = new HashMap();
cachedTypesByMissingSupertypename = new HashMap(10);
}
public void elementChanged(ElementChangedEvent event) {
updateChangedJavaElement(event.getDelta());
}
/**Returns the cached info({@link TypeInfo}) for a given type. Will
* return <code>null</code> if no info has been cached or the the type/something it depends on
* has changed since then.
*
* @param type - the type in question
* @return a TypeInfo instance that contains all cached info for the given type. May be null.
*/
protected TypeInfo getTypeInfo(IType type) {
TypeInfo info = null;
if (type != null)
{
info = cachedInfo.get(type);
}
return info;
}
/**Returns the cached bean property symbols for a given type. Will return null if no
* bean property symbols have been cached or the type/something it depends on has changed since
* then.
* @param beanType - the bean type in question
* @return the bean property symbols for the given type. May be null.
* @see TypeInfoCache#cachePropertySymbols(IType, IBeanPropertySymbol[])
*/
public synchronized IBeanPropertySymbol[] getCachedPropertySymbols(IType beanType) {
IBeanPropertySymbol[] props = null;
if (beanType != null)
{
TypeInfo typeInfo = getTypeInfo(beanType);
if (typeInfo != null)
{
props = typeInfo.getPropertySymbols();
}
}
return props;
}
/**Returns the cached method symbols for a given type. Will return null if no
* method symbols have been cached or the type/something it depends on has changed since
* then.
* @param beanType - the bean type in question
* @return the method symbols for the given type. May be null.
* @see TypeInfoCache#cacheMethodSymbols(IType, IBeanMethodSymbol[])
*/
public synchronized IBeanMethodSymbol[] getCachedMethodSymbols(IType beanType) {
IBeanMethodSymbol[] methods = null;
if (beanType != null)
{
TypeInfo typeInfo = getTypeInfo(beanType);
if (typeInfo != null)
{
methods = typeInfo.getMethodSymbols();
}
}
return methods;
}
/**Returns the cached supertypes for a given type. Will return null if no supertypes
* have been cached for this type or if the type/something it depends on has changed since
* then.
* @param type - the bean type in question
* @return the supertypes for the given type. May be null.
* @see TypeInfoCache#cacheSupertypesFor(IType)
*/
public synchronized IType[] getCachedSupertypes(IType type) {
IType[] types = null;
if (type != null)
{
TypeInfo typeInfo = getTypeInfo(type);
if (typeInfo != null)
{
types = typeInfo.getSupertypes();
}
}
return types;
}
/**Returns the cached implemented interfaces for a given type. Will return null if no interfaces
* have been cached for this type or if the type/something it depends on has changed since
* then.
* @param type - the bean type in question
* @return the interface types implemented by the given type. May be null.
* @see TypeInfoCache#cacheInterfaceTypesFor(IType)
*/
public synchronized IType[] getCachedInterfaceTypes(IType type)
{
IType[] types = null;
if (type != null)
{
TypeInfo typeInfo = getTypeInfo(type);
if (typeInfo != null)
{
types = typeInfo.getInterfaceTypes();
}
}
return types;
}
/**Caches the given method symbols for the given type.
* @param beanType - the type
* @param methods - the method symbols to cache
*/
public synchronized void cacheMethodSymbols(IType beanType, IBeanMethodSymbol[] methods) {
if (beanType != null)
{
TypeInfo typeInfo = getOrCreateTypeInfo(beanType);
if (typeInfo != null) {
typeInfo.setMethodSymbols(methods);
}
}
}
/**Caches the given property symbols for the given type.
* @param beanType - the type
* @param properties - the property symbols to cache
*/
public synchronized void cachePropertySymbols(IType beanType, IBeanPropertySymbol[] properties) {
if (beanType != null)
{
TypeInfo typeInfo = getOrCreateTypeInfo(beanType);
if (typeInfo != null) {
typeInfo.setPropertySymbols(properties);
}
}
}
/**Caches the supertypes for the given type. The supertypes will be calculated (and also returned)
* by this method.
* @param type - the type to cache supertypes for
* @return the supertypes of the given type.
*/
public synchronized IType[] cacheSupertypesFor(IType type)
{
IType[] types = null;
if (type != null)
{
TypeInfo typeInfo = getOrCreateTypeInfo(type);
if (typeInfo != null)
{
types = typeInfo.getSupertypes();
}
}
return types;
}
/**Caches the interface types for the given type. The interface types will be calculated (and also
* returned) by this method.
* @param type - the type to cache interface types for
* @return the interface types implemented by the given type.
*/
public synchronized IType[] cacheInterfaceTypesFor(IType type)
{
IType[] types = null;
if (type != null)
{
TypeInfo typeInfo = getOrCreateTypeInfo(type);
if (typeInfo != null)
{
types = typeInfo.getInterfaceTypes();
}
}
return types;
}
/**Returns the TypeInfo for the given type. If no TypeInfo exists for this type, an empty TypeInfo
* will be created and cached.
* @param type - the type in question
* @return the (modifyable) TypeInfo for the given type
*/
protected TypeInfo getOrCreateTypeInfo(IType type) {
TypeInfo typeInfo = getTypeInfo(type);
if (typeInfo == null) {
try {
final ITypeHierarchy hierarchy =
type.newSupertypeHierarchy(new NullProgressMonitor());
final IType[] supertypes = hierarchy.getAllSuperclasses(type);
final IType[] interfaceTypes = hierarchy.getAllInterfaces();
final IType[] rootClasses = hierarchy.getRootClasses();
List missingSupertypesList = null;
for (int i = 0; i < rootClasses.length; i++) {
String superclassName = rootClasses[i].getSuperclassName();
if (superclassName != null) {
if (missingSupertypesList == null) {
missingSupertypesList = new ArrayList(1);
}
superclassName = shortTypename(superclassName);
missingSupertypesList.add(superclassName);
}
}
String[] missingSupertypes = null;
if (missingSupertypesList != null) {
missingSupertypes = (String[]) missingSupertypesList.toArray(new String[missingSupertypesList.size()]);
} else {
missingSupertypes = TypeInfo.NO_NAMES;
}
typeInfo = new TypeInfo();
typeInfo.setSupertypes(supertypes);
typeInfo.setInterfaceTypes(interfaceTypes);
typeInfo.setMissingSupertypeNames(missingSupertypes);
cachedInfo.put(type, typeInfo);
registerCachedType(type, typeInfo);
} catch (JavaModelException e) {
JSFCommonPlugin.log(e);
}
}
return typeInfo;
}
/**Returns the typename fragment after the last "." (which in most cases is identical to the
* unqualified typename).
* Used only to make sure that if n1 and n2 are names of the same type
* shortname(n1) equals shortname(2) even if one name is qualified and one not.
* @param typename
* @return the typename fragment after the last "."
*/
private String shortTypename(String typename) {
int pos = typename.lastIndexOf('.');
if (pos >= 0) {
typename = typename.substring(pos + 1);
}
return typename;
}
/**
* Registers the given type for all ITypeRoot's it depends on, so that it can be uncached if
* one of this ITypeRoot's has changed. The type must be unregistered when it should not be watched
* anymore.
* @param type - the type
* @param typeInfo - TypeInfo of the given type
* @see TypeInfoCache#unregisterCachedType(IType, TypeInfo)
*/
protected void registerCachedType(IType type, TypeInfo typeInfo) {
registerTypeForTypeRoot(type, type.getTypeRoot());
IType[] supertypes = typeInfo.getSupertypes();
for (int i = 0; i < supertypes.length; i++) {
registerTypeForTypeRoot(type, supertypes[i].getTypeRoot());
}
String[] missingSupertypeNames = typeInfo.getMissingSupertypeNames();
if (missingSupertypeNames != null) {
for (int i = 0; i < missingSupertypeNames.length; i++) {
registerTypeForMissingSupertype(type, missingSupertypeNames[i]);
}
}
}
private void registerTypeForTypeRoot(IType type, ITypeRoot typeRoot) {
Set dependentTypes = cachedTypesByAffectingTypeRoot.get(typeRoot);
if (dependentTypes == null) {
dependentTypes = new HashSet(5);
cachedTypesByAffectingTypeRoot.put(typeRoot, dependentTypes);
}
dependentTypes.add(type);
}
private void registerTypeForMissingSupertype(IType type, String supertype) {
Set dependentTypes = cachedTypesByMissingSupertypename.get(supertype);
if (dependentTypes == null) {
dependentTypes = new HashSet(5);
cachedTypesByMissingSupertypename.put(supertype, dependentTypes);
}
dependentTypes.add(type);
}
/**Unregisters the given type for all ITypeRoot's it depended on.
* @param type - the type
* @param typeInfo - TypeInfo of the given type
*/
protected void unregisterCachedType(IType type, TypeInfo typeInfo) {
unregisterTypeForTypeRoot(type, type.getTypeRoot());
IType[] supertypes = typeInfo.getSupertypes();
for (int i = 0; i < supertypes.length; i++) {
unregisterTypeForTypeRoot(type, supertypes[i].getTypeRoot());
}
String[] missingSupertypeNames = typeInfo.getMissingSupertypeNames();
if (missingSupertypeNames != null) {
for (int i = 0; i < missingSupertypeNames.length; i++) {
unregisterTypeForMissingSupertype(type, missingSupertypeNames[i]);
}
}
}
private void unregisterTypeForTypeRoot(IType type, ITypeRoot typeRoot) {
Set dependentTypes = cachedTypesByAffectingTypeRoot.get(typeRoot);
if (dependentTypes != null) {
dependentTypes.remove(type);
if (dependentTypes.isEmpty()) {
cachedTypesByAffectingTypeRoot.remove(typeRoot);
}
}
}
private void unregisterTypeForMissingSupertype(IType type, String supertype) {
Set dependentTypes = cachedTypesByMissingSupertypename.get(supertype);
if (dependentTypes != null) {
dependentTypes.remove(type);
if (dependentTypes.isEmpty()) {
cachedTypesByMissingSupertypename.remove(supertype);
}
}
}
/**This will remove all cached info for all types.
*/
protected synchronized void uncacheAllTypes() {
cachedInfo.clear();
cachedTypesByAffectingTypeRoot.clear();
cachedTypesByMissingSupertypename.clear();
}
/**Removes all cached info for all types that are subtypes of a type of the given ITypeRoot.
* @param typeRoot
*/
protected synchronized void uncacheAffectedTypes(ITypeRoot typeRoot) {
Collection affectedTypes = cachedTypesByAffectingTypeRoot.get(typeRoot);
if (affectedTypes != null && !affectedTypes.isEmpty()) {
List affectedTypesCopy = new ArrayList(affectedTypes);
for (Iterator it = affectedTypesCopy.iterator(); it.hasNext(); ) {
IType cachedType = (IType) it.next();
TypeInfo typeInfo = cachedInfo.remove(cachedType);
unregisterCachedType(cachedType, typeInfo);
}
}
}
/**Removes all cached info for all types (or subtypes of types) that specify a supertype
* that has a name similar to the given name.
* @param supertypename - the missing supertype name. May be qualified or not
*/
protected synchronized void uncacheTypesWithMissingSupertype(String supertypename) {
Collection affectedTypes = cachedTypesByMissingSupertypename.get(shortTypename(supertypename));
if (affectedTypes != null && !affectedTypes.isEmpty()) {
List affectedTypesCopy = new ArrayList(affectedTypes);
for (Iterator it = affectedTypesCopy.iterator(); it.hasNext(); ) {
IType cachedType = (IType) it.next();
TypeInfo typeInfo = cachedInfo.remove(cachedType);
unregisterCachedType(cachedType, typeInfo);
}
}
}
/**Removes all cached info that may be affected by the given change.
* @param delta - the change in the java model
*/
protected void updateChangedJavaElement(IJavaElementDelta delta) {
IJavaElement element= delta.getElement();
switch (element.getElementType()) {
case IJavaElement.JAVA_MODEL:
updateChangedJavaModel(delta, element);
break;
case IJavaElement.JAVA_PROJECT:
updateChangedJavaProject(delta, element);
break;
case IJavaElement.PACKAGE_FRAGMENT_ROOT:
updateChangedPackageFragmentRoot(delta, element);
break;
case IJavaElement.PACKAGE_FRAGMENT:
updateChangedPackageFragment(delta, (IPackageFragment) element);
break;
case IJavaElement.CLASS_FILE:
case IJavaElement.COMPILATION_UNIT:
updateChangedOpenable(delta, element);
break;
}
}
private void updateChangedChildren(IJavaElementDelta delta) {
if ((delta.getFlags() & IJavaElementDelta.F_CHILDREN) > 0) {
IJavaElementDelta[] children= delta.getAffectedChildren();
for (int i= 0; i < children.length; i++) {
updateChangedJavaElement(children[i]);
}
}
}
private void updateChangedJavaModel(IJavaElementDelta delta, IJavaElement element) {
switch (delta.getKind()) {
case IJavaElementDelta.ADDED :
case IJavaElementDelta.REMOVED :
uncacheAllTypes();
break;
case IJavaElementDelta.CHANGED :
updateChangedChildren(delta);
break;
}
}
private void updateChangedJavaProject(IJavaElementDelta delta, IJavaElement element) {
int kind = delta.getKind();
int flags = delta.getFlags();
if ((flags & IJavaElementDelta.F_OPENED) != 0) {
kind = IJavaElementDelta.ADDED; // affected in the same way
}
if ((flags & IJavaElementDelta.F_CLOSED) != 0) {
kind = IJavaElementDelta.REMOVED; // affected in the same way
}
switch (kind) {
case IJavaElementDelta.ADDED :
case IJavaElementDelta.REMOVED :
uncacheAllTypes();
break;
case IJavaElementDelta.CHANGED :
updateChangedChildren(delta);
break;
}
}
private void updateChangedPackageFragment(IJavaElementDelta delta, IPackageFragment element) {
switch (delta.getKind()) {
case IJavaElementDelta.ADDED :
// if the package fragment is in the projects being considered, this could
// introduce new types, changing the hierarchy
case IJavaElementDelta.REMOVED :
// is a change if the package fragment contains supertypes?
uncacheAllTypes();
break;
case IJavaElementDelta.CHANGED :
// look at the files in the package fragment
updateChangedChildren(delta);
}
}
private void updateChangedPackageFragmentRoot(IJavaElementDelta delta, IJavaElement element) {
switch (delta.getKind()) {
case IJavaElementDelta.ADDED :
case IJavaElementDelta.REMOVED :
uncacheAllTypes();
break;
case IJavaElementDelta.CHANGED :
int flags = delta.getFlags();
if (((flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) > 0)||(flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) > 0) {
uncacheAllTypes();
} else {
updateChangedChildren(delta);
}
break;
}
}
/**Removes all cached info that may be affected by the change in this IOpenable
* @param delta - the change in the java model
* @param element - the (changed) IOpenable considered
*/
protected void updateChangedOpenable(IJavaElementDelta delta, IJavaElement element) {
if (element instanceof ITypeRoot) {
ITypeRoot typeRoot = (ITypeRoot) element;
uncacheAffectedTypes(typeRoot);
// Creates missing superclass for any cached type?
if (delta.getKind() == IJavaElementDelta.ADDED) {
if (typeRoot instanceof ICompilationUnit) {
ICompilationUnit cu = (ICompilationUnit) typeRoot;
try {
IType[] types = cu.getAllTypes();
for (int i = 0; i < types.length; i++) {
uncacheTypesWithMissingSupertype(types[i].getElementName());
}
} catch (JavaModelException e) {
if (!e.isDoesNotExist())
{
JSFCommonPlugin.log(IStatus.INFO, "Unable to get types for compilation unit " + cu, e); //$NON-NLS-1$
}
uncacheAllTypes();
}
} else if (typeRoot instanceof IClassFile) {
IClassFile cf = (IClassFile) typeRoot;
IType type = cf.getType();
uncacheTypesWithMissingSupertype(type.getElementName());
}
}
}
}
}