/***********************************************************************
* Copyright (c) 2008 by SAP AG, Walldorf.
* 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:
* SAP AG - initial API and implementation
***********************************************************************/
package org.eclipse.jst.jee.model.internal.common;
import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IImportDeclaration;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMemberValuePair;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jst.javaee.core.Description;
import org.eclipse.jst.javaee.core.EjbLocalRef;
import org.eclipse.jst.javaee.core.InjectionTarget;
import org.eclipse.jst.javaee.core.JavaeeFactory;
import org.eclipse.jst.javaee.core.ResAuthType;
import org.eclipse.jst.javaee.core.ResSharingScopeType;
import org.eclipse.jst.javaee.core.ResourceRef;
import org.eclipse.jst.javaee.core.RunAs;
import org.eclipse.jst.javaee.core.SecurityRole;
import org.eclipse.jst.javaee.core.SecurityRoleRef;
import org.eclipse.jst.javaee.ejb.SessionBean;
/**
* @author Kiril Mitov k.mitov@sap.com
*
*/
public abstract class AbstractAnnotationFactory {
/**
* @param value
* @return true if "value" is an array of objects.
*/
protected static boolean isArrayOfObject(Object value) {
return Object[].class.isInstance(value);
}
protected Object getAnnotatedValue(String name, IMemberValuePair[] memberValuePairs) throws JavaModelException {
for (IMemberValuePair pair : memberValuePairs) {
if (name.equals(pair.getMemberName())) {
return pair.getValue();
}
}
return null;
}
protected boolean containsImport(ICompilationUnit unit, String importt) throws JavaModelException {
for (IImportDeclaration declaration : unit.getImports()) {
if (declaration.getElementName().equals(importt))
return true;
}
return false;
}
/**
* Resolve the given <code>toResolve</code> string to an IType in the
* context of <code>declaringType</code>
*
* @param declaringType
* @param toResolve
* the type that should be resolved.
* @return the resolved type or <code>null</code> if such type can not be
* resolved. Returns <code>null</code> if toResolve is
* <code>null</code>
* @throws JavaModelException
*/
protected IType resolveType(IType declaringType, String toResolve) throws JavaModelException {
if (toResolve == null)
return null;
String[][] fullTypeName = declaringType.resolveType(toResolve);
if (fullTypeName != null)
return declaringType.getJavaProject().findType(fullTypeName[0][0], fullTypeName[0][1]);
return null;
}
protected void processEjbAnnotation(IAnnotation annotation, List<EjbLocalRef> localRefs, IMember member,
Collection<IType> dependedTypes) throws JavaModelException {
int memberType = member.getElementType();
IMemberValuePair[] pairs = annotation.getMemberValuePairs();
String beanInterfaceValue = (String) getAnnotatedValue("beanInterface", pairs); //$NON-NLS-1$
beanInterfaceValue = internalProcessInjection(beanInterfaceValue, member, dependedTypes);
if (beanInterfaceValue == null)
return;
/*
* The name of the reference should be the value of the "name"
* attribute. If there is no "name" attribute then the name of the
* reference is the qualified name of the member. Check this at
* Enterprise Java Beans, 3.0, Section 14.1.5.3
*/
String refName = (String) getAnnotatedValue("name", pairs); //$NON-NLS-1$
if (refName == null) {
refName = getMemberQualifiedName(member);
}
EjbLocalRef ref = JavaeeFactory.eINSTANCE.createEjbLocalRef();
ref.setEjbRefName(refName);
localRefs.add(ref);
ref.setLocal(beanInterfaceValue);
ref.setLocalHome(beanInterfaceValue);
ref.setEjbLink((String) getAnnotatedValue("beanName", pairs)); //$NON-NLS-1$
ref.setMappedName((String) getAnnotatedValue("mappedName", pairs)); //$NON-NLS-1$
if (memberType == IJavaElement.METHOD || memberType == IJavaElement.FIELD) {
createInjectionTarget(refName, ref.getInjectionTargets(), annotation);
}
}
private void createInjectionTarget(String refName, List<InjectionTarget> injectionTargets, IAnnotation annotation) {
InjectionTarget injectionTarget = JavaeeFactory.eINSTANCE.createInjectionTarget();
int index = refName.indexOf('/');
if (index != -1) {
injectionTarget.setInjectionTargetClass(refName.substring(0, index));
injectionTarget.setInjectionTargetName(refName.substring(index + 1));
} else {
injectionTarget.setInjectionTargetName(refName);
injectionTarget.setInjectionTargetClass("");//$NON-NLS-1$
}
injectionTargets.add(injectionTarget);
}
/**
* Resource annotation can be placed on class, method, field.
*
* Checks are made if the resource annotation is valid.
* <p>
* If on class there should be a "type" attribute. If on method the method
* must have one param with type that is an interface. If on field the field
* type must be an interface.
*
* If the type of the method/field can not be resolved the result will
* contain the unresolved value.
*
* In case the type of method/field is array, wildcard, simple type this is
* not a place for the annotation.
* </p>
*
* <p>
* In case of method/field the type specified using the "type" attribute has
* a higher priority that the method/field type.
* </p>
*
* <p>
* Only resolved types are added to dependedTypes
* </p>
*
* @param sessionBean
* @param member
* @param annotation
* @param dependedTypes
* @throws JavaModelException
*/
protected void processResourceRefAnnotation(IAnnotation annotation, List<ResourceRef> resourceRefs, IMember member,
Collection<IType> dependedTypes) throws JavaModelException {
IMemberValuePair[] pairs = annotation.getMemberValuePairs();
String specifiedType = (String) getAnnotatedValue("type", pairs); //$NON-NLS-1$
specifiedType = internalProcessInjection(specifiedType, member, dependedTypes);
if (specifiedType == null)
return;
String refName = (String) getAnnotatedValue("name", pairs); //$NON-NLS-1$
if (refName == null)
refName = getMemberQualifiedName(member);
ResourceRef ref = JavaeeFactory.eINSTANCE.createResourceRef();
ref.setResRefName(refName);
ref.setResType(specifiedType);
ref.setMappedName((String) getAnnotatedValue("mappedName", pairs)); //$NON-NLS-1$
String description = (String) getAnnotatedValue("description", pairs); //$NON-NLS-1$
if (description != null) {
Description desc = JavaeeFactory.eINSTANCE.createDescription();
desc.setValue(description);
ref.getDescriptions().clear();
ref.getDescriptions().add(desc);
}
if (member.getElementType() == IJavaElement.METHOD || member.getElementType() == IJavaElement.FIELD) {
createInjectionTarget(refName, ref.getInjectionTargets(), annotation);
}
String value = (String) getAnnotatedValue("authenticationType", pairs); //$NON-NLS-1$
/*
* the default value is AuthenticationType.APPLICATION which is handled
* by the EMF. no need to check for this value
*/
if ("AuthenticationType.CONTAINER".equals(value)) { //$NON-NLS-1$
ref.setResAuth(ResAuthType.CONTAINER_LITERAL);
} else if ("CONTAINER".equals(value) //$NON-NLS-1$
&& containsImport(member.getCompilationUnit(), "AuthenticationType.CONTAINER")) { //$NON-NLS-1$
ref.setResAuth(ResAuthType.CONTAINER_LITERAL);
}
Boolean shareable = (Boolean) getAnnotatedValue("shareable", pairs); //$NON-NLS-1$
/*
* The default value for sharable is true. Check and process only
* unsharable
*/
if (Boolean.FALSE.equals(shareable))
ref.setResSharingScope(ResSharingScopeType.UNSHAREABLE_LITERAL);
resourceRefs.add(ref);
}
/**
* The method has the task of processing the member along with the specified
* member and return a String. The result is to be used as a reference value
* for the injection on this member. Usage are the
*
* @EJB and
* @Resource annotations.
*
* <p>
* If the specifiedType is <code>null</code> and member is of type
* IJavaElement.TYPE the method returns <code>null</code>
* </p>
*
* <p>
* If the type of the member can be resolved and is an interface the method
* returns <code>null</code>. Here the "type" of the member is the result
* from {@link #getUnresolvedType(IMember)}
* </p>
*
*
* Only if the specifiedType can be calculated and is resolved it is added
* to the dependedTypes. If the specifiedType can not be resolved nothing is
* added to dependedTypes.
*
* @see {@link #processEjbAnnotation(IAnnotation, SessionBean, IMember, Collection)}
* @see #processResourceRefAnnotation(SessionBean, IMember, IAnnotation,
* Collection)
*
* @param specifiedType
* @param member
* @param dependedTypes
* @return
* @throws JavaModelException
*/
private String internalProcessInjection(final String specifiedType, IMember member, Collection<IType> dependedTypes)
throws JavaModelException {
boolean methodOrField = member.getElementType() == IJavaElement.METHOD
|| member.getElementType() == IJavaElement.FIELD;
IType declaringType = (IType) (member.getElementType() == IJavaElement.TYPE ? member : member
.getDeclaringType());
String memberType = getUnresolvedType(member);
// not type for this member can be retrieved. If member is a method or
// field this means there is an error.
if (getClassTypeSignature(memberType) == null && methodOrField)
return null;
// both type are null. This is not a valid case. This will hapen for a
// type without specified type.
if (specifiedType == null && memberType == null)
return null;
String innerSpecifiedType = specifiedType;
IType resolvedType = resolveType(declaringType, memberType);
// we were able to get a type for the param of a method or type of
// a field.
// check if it is an interface. It might not be resolved, but we have a
// value
// for unresolved.
if (methodOrField) {
// if the resolved type is not null and it is not an interface this
// annotation is not valid
if (resolvedType != null) {
if (resolvedType.isInterface())
memberType = resolvedType.getFullyQualifiedName();
else
// invalid - if the method is with param that is not an
// interface. Or the type of the field is not an interface.
return null;
}
}
// from now one use only the specified type for type resolving. If there
// is no specified type use the member type. The check for whether they
// were both null is previously made
IType resolvedSpecifiedType = null;
if (innerSpecifiedType == null) {
innerSpecifiedType = memberType;
resolvedSpecifiedType = resolvedType;
} else
resolvedSpecifiedType = resolveType(declaringType, innerSpecifiedType);
if (resolvedSpecifiedType != null) {
if (resolvedSpecifiedType.isInterface()) {
innerSpecifiedType = resolvedSpecifiedType.getFullyQualifiedName();
dependedTypes.add(resolvedSpecifiedType);
} else
// we have resolved the specified type and it is not an
// interface. Not a valid annotation.
return null;
}
return innerSpecifiedType;
}
/**
* This method returns a qualified name for this member. The name is to be
* used as ejb-ref-name.
*
* If the member is a type then fullyQualifiedName of the type is returned.
*
* If the member is a <code>field</code> declared in a <code>type</code>
* then the result is
* <code>type.getFullyQualifiedName() +"/" + field.elementName</code>
*
* If the member is a <code>method</code> declared in a <code>type</code>
* and method name begins with "set" then: for type name =
* "org.eclipse.Bean" and method name = "setMethodOne()" the result is
* "org.eclipse.Bean/methodOne"
*
* Check this at Enterprise Java Beans, 3.0, Section 14.1.5.3
*
* @param member
* @return
*/
private String getMemberQualifiedName(IMember member) {
String memberName = member.getElementName();
int elementType = member.getElementType();
if (elementType == IJavaElement.METHOD && memberName.startsWith("set")) { //$NON-NLS-1$
char ch = Character.toLowerCase(memberName.charAt(3));
memberName = ch + memberName.substring(4);
}
return elementType == IJavaElement.TYPE ? ((IType) member).getFullyQualifiedName() : member.getDeclaringType()
.getFullyQualifiedName()
+ "/" + memberName; //$NON-NLS-1$
}
/**
* Return the javaee type of this member. For types return <code>null</code>.
* For methods with one param return the java type of this param. For fields
* return the return the java type of the field.
*
* If the result is <code>null</code> then this member is not valid and a
* javaee type can not be returned. This may happen for a method with more
* then one param or for a field with a class type or primitive type
*
* @param member
* @param memberType
*
* @return
* @throws JavaModelException
*/
private String getUnresolvedType(IMember member) throws JavaModelException {
int memberType = member.getElementType();
String unresolvedTypeName = null;
if (memberType == IJavaElement.FIELD) {
unresolvedTypeName = Signature.toString(((IField) member).getTypeSignature());
} else if (memberType == IJavaElement.METHOD) {
IMethod method = (IMethod) member;
if (method.getNumberOfParameters() != 1)
return null;
unresolvedTypeName = Signature.toString(method.getParameterTypes()[0]);
} else if (memberType == IJavaElement.TYPE)
return null;
return unresolvedTypeName;
}
/**
* Returns the type signature for toResolve only if toResolve is a class or
* interface.
*
* @param toResolve
* @return <code>null</code> if toResolve is <code>null</code> or simple
* type, array type, wildcard type
*
*/
private String getClassTypeSignature(String toResolve) {
if (toResolve == null)
return null;
String innerToResolve = Signature.createTypeSignature(toResolve, false);
if (Signature.getTypeSignatureKind(innerToResolve) != Signature.CLASS_TYPE_SIGNATURE)
return null;
return innerToResolve;
}
protected void processDeclareRoles(Result result, List<SecurityRoleRef> securityRoleRefs, IAnnotation annotation,
IType type) throws JavaModelException {
IMemberValuePair[] pairs = annotation.getMemberValuePairs();
Object values = getAnnotatedValue("value", pairs); //$NON-NLS-1$
if (!isArrayOfObject(values))
return;
for (Object roleName : (Object[]) values) {
SecurityRole role = JavaeeFactory.eINSTANCE.createSecurityRole();
role.setRoleName((String) roleName);
result.getAdditional().add(role);
SecurityRoleRef ref = JavaeeFactory.eINSTANCE.createSecurityRoleRef();
ref.setRoleName((String) roleName);
securityRoleRefs.add(ref);
}
}
protected void processResourcesAnnotation(IAnnotation annotation, List<ResourceRef> resourceRefs, IType type,
Collection<IType> dependedTypes) throws JavaModelException {
IMemberValuePair[] pairs = annotation.getMemberValuePairs();
if (!isArrayOfObject(pairs[0].getValue()))
return;
Object[] values = (Object[]) pairs[0].getValue();
for (Object resourceAnnotation : values) {
processResourceRefAnnotation((IAnnotation) resourceAnnotation, resourceRefs, type, dependedTypes);
}
}
protected void processRunAs(IAnnotation annotation,RunAs runAs) throws JavaModelException {
IMemberValuePair[] pairs = annotation.getMemberValuePairs();
if (pairs.length == 1) {
String value = (String) getAnnotatedValue("value", pairs); //$NON-NLS-1$
runAs.setRoleName(value);
}
}
}