/*******************************************************************************
* 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.designtime.internal.view;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IConfigurationContributor;
import org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory;
import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
import org.eclipse.jem.internal.proxy.ide.IDERegistration;
import org.eclipse.jst.jsf.common.internal.types.TypeInfoCache;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentTypeInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorTypeInfo;
import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.core.internal.JSFCoreTraceOptions;
import org.eclipse.jst.jsf.core.internal.jem.BeanProxyUtil.BeanProxyWrapper;
import org.eclipse.jst.jsf.core.internal.jem.BeanProxyUtil.ProxyException;
import org.eclipse.jst.jsf.core.jsfappconfig.internal.IJSFAppConfigManager;
import org.eclipse.jst.jsf.core.jsfappconfig.internal.JSFAppConfigManagerFactory;
import org.eclipse.jst.jsf.facesconfig.emf.ComponentType;
import org.eclipse.jst.jsf.facesconfig.emf.ConverterType;
import org.eclipse.jst.jsf.facesconfig.emf.ValidatorType;
/**
* Utility class for finding and bean introspecting component and related
* classes.
*
* @author cbateman
*
*/
public final class DTComponentIntrospector
{
/**
* A shared type cache for doing tag class introspection. The cache stores
* type hierarchies and updates them on detected changes to reduce the
* overhead of doing such lookups
*/
private static TypeInfoCache TYPE_CACHE; // lazily created, don't access
// directly
/**
* @return the type cache used by all DTComponentIntrospector internally.
*/
public static TypeInfoCache getSharedTypeCache()
{
if (TYPE_CACHE == null)
{
TYPE_CACHE = TypeInfoCache.createNewInstance();
}
return TYPE_CACHE;
}
/**
* @param classType
* @param className
* @param project
* @param contributors may be null
* @return the component type info for the class type or null if none. Adds
* contributors to the class path
*/
public static ComponentTypeInfo getComponent(final String classType,
final String className, final IProject project,
final IConfigurationContributor[] contributors)
{
ProxyFactoryRegistry registry = null;
try
{
registry = getProxyFactoryRegistry(project,
contributors);
if (registry != null)
{
final IStandardBeanTypeProxyFactory factory = registry
.getBeanTypeProxyFactory();
final IBeanTypeProxy classTypeProxy = factory
.getBeanTypeProxy(className);
final BeanProxyWrapper classTypeWrapper = new BeanProxyWrapper(project,
classTypeProxy);
String family = null;
String renderer = null;
try
{
classTypeWrapper.init();
family = classTypeWrapper.callStringMethod("getFamily"); //$NON-NLS-1$
renderer = classTypeWrapper.callStringMethod("getRendererType"); //$NON-NLS-1$
}
catch (ProxyException e1)
{
// fall through
if (JSFCoreTraceOptions.TRACE_JSPTAGINTROSPECTOR)
{
JSFCoreTraceOptions.log("DTComponentIntrospector.getComponent:", e1); //$NON-NLS-1$
}
}
IType type = null;
try
{
type = JavaCore.create(project).findType(className);
}
catch (JavaModelException e)
{
// fall through;
}
List<String> interfaces = new ArrayList<String>();
List<String> superClasses = new ArrayList<String>();
if (type != null)
{
TypeInfoCache typeCache = getSharedTypeCache();
IType[] interfaceTypes = typeCache.cacheInterfaceTypesFor(type);
for (IType interfaze : interfaceTypes)
{
interfaces.add(interfaze.getFullyQualifiedName());
}
IType[] superClassTypes = typeCache.cacheSupertypesFor(type);
for (IType superClass : superClassTypes)
{
superClasses.add(superClass.getFullyQualifiedName());
}
}
return new ComponentTypeInfo(classType, className, superClasses
.toArray(new String[0]), interfaces.toArray(new String[0]),
family, renderer);
}
}
finally
{
if (registry != null)
{
registry.terminateRegistry(true);
}
}
return null;
}
/**
* @param classType
* @param className
* @param project
* @return the component type info with no additional classpath
* contributions. May return null;
*/
public static ComponentTypeInfo getComponent(final String classType,
final String className, final IProject project)
{
return getComponent(classType, className, project, null);
}
/**
* @param converterId
* @param converterClass
* @return a new converter type info for the converter id.
*/
public static ConverterTypeInfo getConverter(final String converterId,
final String converterClass)
{
return new ConverterTypeInfo(converterClass, converterId);
}
/**
* @param validatorId
* @param validatorClass
* @return a new validator type info for the validator id
*/
public static ValidatorTypeInfo getValidator(final String validatorId,
final String validatorClass)
{
return new ValidatorTypeInfo(validatorClass, validatorId);
}
/**
* @param componentType
* @param project
* @return the configured class name for the JSF component type id or null
* if not found.
*/
public static String findComponentClass(final String componentType,
final IProject project)
{
final IJSFAppConfigManager manager = JSFAppConfigManagerFactory
.getJSFAppConfigManagerInstance(project);
final List<ComponentType> components = manager.getComponents();
for (final ComponentType component : components)
{
final String type = component.getComponentType().getTextContent()
.trim();
if (componentType.equals(type) && component.getComponentClass() != null && component.getComponentClass().getTextContent() != null)
{
return component.getComponentClass().getTextContent().trim();
}
}
return null;
}
/**
* @param converterId
* @param project
* @return a fully qualified class name corresponding to converterId or null
* if none.
*/
public static String findConverterClass(final String converterId,
final IProject project)
{
final IJSFAppConfigManager manager = JSFAppConfigManagerFactory
.getJSFAppConfigManagerInstance(project);
final List<ConverterType> converters = manager.getConverters();
for (final ConverterType converter : converters)
{
if (converter != null && converter.getConverterId() != null
&& converter.getConverterId().getTextContent() != null)
{
final String type = converter.getConverterId().getTextContent()
.trim();
if (converterId.equals(type))
{
if (converter.getConverterClass() != null && converter.getConverterClass().getTextContent()!=null)
{
return converter.getConverterClass().getTextContent()
.trim();
}
return null;
}
}
}
return null;
}
/**
* @param validatorId
* @param project
* @return a fully qualified class name corresponding to the validatorId or
* null if none.
*/
public static String findValidatorClass(final String validatorId,
final IProject project)
{
final IJSFAppConfigManager manager = JSFAppConfigManagerFactory
.getJSFAppConfigManagerInstance(project);
final List<ValidatorType> validators = manager.getValidators();
for (final ValidatorType validatorType : validators)
{
if (validatorType != null && validatorType.getValidatorId() != null &&
validatorType.getValidatorId().getTextContent() != null)
{
final String type = validatorType.getValidatorId().getTextContent()
.trim();
if (validatorId.equals(type))
{
return validatorType.getValidatorClass().getTextContent()
.trim();
}
}
}
return null;
}
/**
* @param type
* @param checkInstanceOf
* @return true if type resolves to a type that is an instance of one of the
* types in checkInstanceOf.
*/
public static boolean isTypeNameInstanceOfClass(final IType type,
final Set<String> checkInstanceOf)
{
if (checkInstanceOf == null)
{
throw new AssertionError();
}
if (type != null)
{
// first and foremost, are these exactly droids you're
// looking for and not just their predecessors?
if (checkInstanceOf.contains(type.getFullyQualifiedName()))
{
return true;
}
for (final IType supertype : getSharedTypeCache()
.cacheSupertypesFor(type))
{
if (checkInstanceOf.contains(supertype.getFullyQualifiedName()))
{
return true;
}
}
for (final IType interfaces : getSharedTypeCache()
.cacheInterfaceTypesFor(type))
{
if (checkInstanceOf
.contains(interfaces.getFullyQualifiedName()))
{
return true;
}
}
}
return false;
}
/**
* @param typeInfo
* @param project
* @return a list of all bean properties (using the POJO method) on
* typeInfo. List may be empty, never null.
*/
public static Map<String, JDTBeanProperty> getBeanProperties(
final ComponentTypeInfo typeInfo, final IProject project)
{
Map<String, JDTBeanProperty> properties = new HashMap<String, JDTBeanProperty>();
IJavaProject javaProject = JavaCore.create(project);
try
{
IType type = javaProject.findType(typeInfo.getClassName());
if (type != null)
{
// TODO: should be able to use type cache for this
final JDTBeanIntrospector introspector = new JDTBeanIntrospector(
type);
properties = introspector.getProperties();
}
}
catch (JavaModelException e)
{
JSFCorePlugin.log("Error finding component type", e); //$NON-NLS-1$
}
return properties;
}
/**
* @param project
* @return a new proxy factory registry or null;
*
* TODO: caching?
*/
private static ProxyFactoryRegistry getProxyFactoryRegistry(
final IProject project, final IConfigurationContributor[] contributors)
{
try
{
return IDERegistration.startAnImplementation(contributors, false, project,
project.getName(), JSFCorePlugin.PLUGIN_ID,
new NullProgressMonitor());
}
catch (final CoreException e)
{
JSFCorePlugin.log("Error starting vm for project: " //$NON-NLS-1$
+ project.getName(), e);
}
return null;
}
private DTComponentIntrospector()
{
// no external instantiation
}
// private static class
}