/*******************************************************************************
* Copyright (c) 2008 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:
* Matthias Fuessel -- extracted from https://bugs.eclipse.org/bugs/show_bug.cgi?id=215461
* Cameron Bateman/Oracle - integrated and moved data table code here.
*
********************************************************************************/
package org.eclipse.jst.jsf.designtime.symbols;
import java.util.Arrays;
import java.util.HashMap;
import org.eclipse.core.resources.IFile;
import org.eclipse.emf.common.util.ECollections;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.internal.types.ValueType;
import org.eclipse.jst.jsf.common.util.TypeUtil;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.symbol.ERuntimeSource;
import org.eclipse.jst.jsf.context.symbol.IBeanInstanceSymbol;
import org.eclipse.jst.jsf.context.symbol.IComponentSymbol;
import org.eclipse.jst.jsf.context.symbol.IInstanceSymbol;
import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
import org.eclipse.jst.jsf.context.symbol.IMapTypeDescriptor;
import org.eclipse.jst.jsf.context.symbol.IObjectSymbol;
import org.eclipse.jst.jsf.context.symbol.ISymbol;
import org.eclipse.jst.jsf.context.symbol.InitializedSymbolFactory;
import org.eclipse.jst.jsf.context.symbol.SymbolFactory;
import org.eclipse.jst.jsf.context.symbol.internal.util.IObjectSymbolBasedValueType;
import org.eclipse.jst.jsf.designtime.resolver.IStructuredDocumentSymbolResolverFactory;
import org.eclipse.jst.jsf.designtime.resolver.StructuredDocumentSymbolResolverFactory;
import org.eclipse.jst.jsf.validation.internal.IJSFViewValidator.IValidationReporter;
import org.eclipse.jst.jsf.validation.internal.IJSFViewValidator.ReporterAdapter;
import org.eclipse.jst.jsf.validation.internal.el.ELExpressionValidator;
import org.eclipse.jst.jsf.validation.internal.el.IExpressionSemanticValidator;
/**
* Factory for creating symbols for variables/message bundles that are
* contributed by components/tags. This Factory can be used by descendants of
* {@link org.eclipse.jst.jsf.context.symbol.source.AbstractContextSymbolFactory} in order to create the symbols they want
* to contribute.
*
* It provides also methods for getting the resulting {@link ValueType} from an
* EL expression and the "row" type signature from an DataModel/Array/List
* {@link ValueType}.
*
* NOTE: C.B March 26, 2008 -- commented out portions are left for the future
* because the rely on enhancements to the symbol model that could not be made
* in the current release. Other portions of the original ComponentSymbolFactory
* have been moved to {@link org.eclipse.jst.jsf.context.symbol.InitializedSymbolFactory}
* This reflects the split between things deemed to be generic EL (put in common
* plugin) and things deemed to be JSF-specific (put here).
*
*/
public final class JSFSymbolFactory extends InitializedSymbolFactory
{
/**
* @param elText The EL expression text. Must not be null
* @param elContext The document context pointing to elText in the source document. Must not be null
* @param file The workspace resource that contains elText. Must not be null.
* @param symbolResolverFactory
* @return the value expression resolved from elText or null if it cannot
* be resolved or elText doesn't resolve to value expression (i.e. is a method expression)
*/
public ValueType getValueTypeFromEL(final String elText,
final IStructuredDocumentContext elContext, final IFile file, IStructuredDocumentSymbolResolverFactory symbolResolverFactory)
{
assert elText != null;
assert elContext != null;
assert file != null;
// TODO investigate if infinite recursion; use ASTResolver instead??
final IValidationReporter reporter = new ReporterAdapter();
final ELExpressionValidator validator =
new ELExpressionValidator(
elContext, elText, symbolResolverFactory, reporter);
validator.validateXMLNode();
final IExpressionSemanticValidator semValidator = validator
.getSemanticValidator();
if (semValidator != null
&& semValidator.getExpressionType() instanceof ValueType)
{
return (ValueType) semValidator.getExpressionType();
}
return null;
}
/**
* Convenience for {@link JSFSymbolFactory#getValueTypeFromEL(String, IStructuredDocumentContext, IFile, IStructuredDocumentSymbolResolverFactory)}
* using StructuredDocumentSymbolResolverFactory.getInstance().
*
* @param elText
* @param elContext
* @param file
* @return a ValueType or null
*/
public ValueType getValueTypeFromEL(final String elText,
final IStructuredDocumentContext elContext, final IFile file)
{
return getValueTypeFromEL(elText, elContext, file, StructuredDocumentSymbolResolverFactory.getInstance());
}
/**
* @param type
* @return <code>true</code>, if the given {@link ValueType} represents
* an instance of <code>javax.faces.model.DataModel</code>
*/
private boolean isFacesDataModel(ValueType type)
{
return type.isInstanceOf(TypeConstants.TYPE_DATA_MODEL);
}
/**
* Tries to guess the row type of a <code>javax.faces.DataModel</code>
* instance. This will only work if <code>type</code> is a descendant that
* narrows down the return type of "getRowData()".
*
* @param type
* @return the row type of the given DataModel. Will return
* <code>null</code> if <code>type</code> is no DataModel or if
* nothing more specific than <code>Object</code> can be
* determined
*/
public String getRowSignatureFromDataModel(ValueType type)
{
if (type instanceof IObjectSymbolBasedValueType)
{
ISymbol resSymbol = ((IObjectSymbolBasedValueType) type)
.getSymbol().call(
"getRowData", ECollections.emptyEList(), "res"); //$NON-NLS-1$ //$NON-NLS-2$
if (resSymbol != null && resSymbol instanceof IObjectSymbol)
{
// TODO full signature
final String signature = ((IObjectSymbol) resSymbol)
.getTypeDescriptor().getTypeSignature();
if (!TypeConstants.TYPE_JAVAOBJECT.equals(signature))
{
return signature;
}
}
}
return null;
}
/**
* @param type
* @return <code>true</code>, if <code>type</code> is a collection or
* array
*/
public boolean isContainerType(ValueType type)
{
return type.isArray()
|| type.isInstanceOf(TypeConstants.TYPE_COLLECTION);
}
/**
* @param type -
* the type of the <code>value</code> property
* @return the type signature of the row variable for every type that
* <code>UIData</code> takes as <code>value</code> property.
* Will return <code>null</code> if no type or nothing more
* specific than <code>Object</code> can be determined
*/
public String getRowSignatureFromValueType(ValueType type)
{
if (isContainerType(type))
{
return getElementSignatureFromContainerType(type);
}
if (isFacesDataModel(type))
{
return getRowSignatureFromDataModel(type);
}
// Otherwise, according to jsf spec, treat value as single row:
// TODO full signature
return type.getSignature();
}
/**
* @param symbolName The name of the symbol to be created. Must not be null
* @param signature The type signature of the array type. Must not be null
* @param source the runtime source
* @param javaProject must not be null
* @return a symbol based approximating an implicit DataModel wrapper for an array
*/
public final ISymbol createArraySymbol(final String symbolName, final String signature, final ERuntimeSource source, final IJavaProject javaProject)
{
assert symbolName != null;
assert signature != null;
assert javaProject != null;
final String arrayElementType = Signature.getElementType(signature);
final int arrayCount = Signature.getArrayCount(signature);
String adjustedSignature = null;
// if it is a single array nesting, then it will just be the element type,
// but if it is a multi-dim array, then the scalar element will be an array
// with one less nesting level. It's a strange corner case to have an implicit
// array of something as a row type, but it is a valid case. I suppose
// it may be happen if you want to have tables of tables in which the nested tables
// in turn use nested variables as their type...
if (arrayCount > 0)
{
adjustedSignature = Signature.createArraySignature(arrayElementType, arrayCount-1);
}
else
{
adjustedSignature = arrayElementType;
}
return createScalarSymbol(symbolName, adjustedSignature, source, javaProject);
}
/**
* @param symbolName The name of the symbol to create. Must not be null.
* @param signature The fully resolved type signature of the scalar. Must not be null.
* @param source
* @param javaProject The JavaProject whose classpath is to be used to resolve type information for signture. Must not be null.
* @return a symbol approximating a scalar object DataModel wrapper. The row variable for the
* data model becomes of type signature
*/
public final ISymbol createScalarSymbol(final String symbolName, final String signature, final ERuntimeSource source, final IJavaProject javaProject)
{
assert symbolName != null;
assert signature != null;
assert javaProject != null;
final String elementType = Signature.getElementType(signature);
IJavaTypeDescriptor2 desc =
SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
final int arrayCount = Signature.getArrayCount(signature);
if (arrayCount > 0)
{
desc.setArrayCount(arrayCount);
}
IType type = TypeUtil.resolveType(javaProject, elementType);
if (type != null)
{
desc.setType(type);
}
else
{
desc.setTypeSignatureDelegate(Signature.getTypeErasure(signature));
}
desc.getTypeParameterSignatures().addAll(Arrays.asList(Signature.getTypeArguments(signature)));
IComponentSymbol symbol = SymbolFactory.eINSTANCE.createIComponentSymbol();
symbol.setName(symbolName);
symbol.setTypeDescriptor(desc);
symbol.setRuntimeSource(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL);
return symbol;
}
/**
* @param symbolName The name of the symbol to create. Must not be null.
* @param valueType The value expression representing the implicit list. The signature
* on the valueType must be a list. Must not be null.
* @param source
* @param description
* @param javaProject The JavaProject whose classpath will be used to resolve types. Must not be null.
*
* @return a symbol that approximates as best as possible an implicit DataModel for java.util.List value expressions. If the List has
* resolvable Java 5 type arguments, then a scalar symbol will be created
* using this type information. If it is a raw type, then
* createDefaultSymbol() is called
*/
public final ISymbol createFromList(String symbolName, ValueType valueType, ERuntimeSource source, String description, IJavaProject javaProject)
{
assert symbolName != null;
assert valueType != null;
assert javaProject != null;
assert TypeConstants.TYPE_LIST.equals(valueType.getSignature());
final String[] typeArguments = valueType.getTypeArguments();
if (typeArguments != null && typeArguments.length > 0)
{
// a list has a single type argument
final String typeArg = typeArguments[0];
if (Signature.getTypeSignatureKind(typeArg) == Signature.CLASS_TYPE_SIGNATURE)
{
return createScalarSymbol(symbolName, typeArg, source, javaProject);
}
}
// if no resolvable type signatures, do the default thing
return createDefaultSymbol(symbolName, ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL, description);
}
/**
* @param symbolName The name of the symbol to create. Must not be null
* @param source
* @param description
* @return a default symbol that eliminates bogus warnings for this dataTable's
* row variable in cases where something better is resolvable. Note that this is
* not ideal, since will result in any property being accepted on the variable with
* this name.
*/
public final ISymbol createDefaultSymbol(final String symbolName, final ERuntimeSource source, final String description)
{
assert symbolName != null;
final IMapTypeDescriptor typeDesc =
SymbolFactory.eINSTANCE.createIBoundedMapTypeDescriptor();
// empty map source
typeDesc.setMapSource(new HashMap());
final IComponentSymbol symbol =
SymbolFactory.eINSTANCE.createIComponentSymbol();
symbol.setName(symbolName);
symbol.setTypeDescriptor(typeDesc);
symbol.setDetailedDescription(description);
symbol.setRuntimeSource(source);
return symbol;
}
/**
* FUTURE use: added to support future API feature. Should not be used.
* @param symbolName
* @param bundleName
* @param project
* @return an instance symbol for the message bundle
*/
public IInstanceSymbol createMessageBundleSymbol(final String symbolName, final String bundleName, IJavaProject project)
{
// FUTURE USE
throw new UnsupportedOperationException("see https://bugs.eclipse.org/bugs/show_bug.cgi?id=215461"); //$NON-NLS-1$
}
/**
* FUTURE use: added to support future API feature. Should not be used.
* @param symbolName
* @param fullyQualifiedName
* @param source
* @param description
* @param javaProject
* @return an instance symbol for the message bundle
*/
public IBeanInstanceSymbol createManagedBeanSymbol(final String symbolName, final String fullyQualifiedName,
ERuntimeSource source, final String description, final IJavaProject javaProject)
{
// FUTURE USE
throw new UnsupportedOperationException("see https://bugs.eclipse.org/bugs/show_bug.cgi?id=215461"); //$NON-NLS-1$
}
// / /**
// * @param symbolName
// * @param signature
// * @param javaProject
// * @return a symbol for a bean
// */
// public IComponentBeanSymbol createBeanSymbolFromSignature(
// final String symbolName, final String signature,
// final IJavaProject javaProject)
// {
// IJavaTypeDescriptor2 desc = createTypeDescriptorFromSignature(
// signature, javaProject);
//
// IComponentBeanSymbol symbol = SymbolFactory.eINSTANCE
// .createIComponentBeanSymbol();
// symbol.setName(symbolName);
// symbol.setTypeDescriptor(desc);
// symbol.setRuntimeSource(ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL);
// return symbol;
// }
// /**
// * @param symbolName
// * @param bundleName
// * @param project
// * @return a symbol for a message bundle
// */
// public IMessageBundleSymbol createMessageBundleSymbolFromBundleName(final String symbolName, final String bundleName, IJavaProject project) {
// final IMessageBundleTypeDescriptor typeDesc = SymbolFactory.eINSTANCE.createIMessageBundleTypeDescriptor();
// try {
// Map mapSource = ResourceBundleMapSourceFactory.getResourceBundleMapSource(project.getProject(), bundleName);
// typeDesc.setMapSource(mapSource);
// } catch (JavaModelException e) {
// JSFCorePlugin.log(e, "Error creating resource map for bundle '"bundleName "'"); //$NON-NLS-1$ //$NON-NLS-2$
// } catch (IOException e) {
// JSFCorePlugin.log(e, "Error creating resource map for bundle '"bundleName "'"); //$NON-NLS-1$ //$NON-NLS-2$
// } catch (CoreException e) {
// JSFCorePlugin.log(e, "Error creating resource map for bundle '"bundleName "'"); //$NON-NLS-1$ //$NON-NLS-2$
// }
// final IMessageBundleSymbol symbol = SymbolFactory.eINSTANCE.createIMessageBundleSymbol();
// symbol.setName(symbolName);
// symbol.setTypeDescriptor(typeDesc);
// symbol.setDetailedDescription(NLS.bind(Messages.getString("ComponentSymbolFactory.IMessageBundleSymbol.detailedDescription"), bundleName)); //$NON-NLS-1$
// return symbol;
// }
// /**
// * Sets the symbol to be defined only inside the given element
// *
// * @param symbol
// * @param slement
// */
// public void setDefinitionRange(final IComponentVar symbol,
// final Element slement)
// {
// if (slement instanceof IndexedRegion)
// {
// final IndexedRegion defRegion = (IndexedRegion) slement;
// final int defOffset = defRegion.getStartOffset();
// final int defLength = defRegion.getLength();
// symbol.setDefinitionRange(defOffset, defLength);
// }
// }
}