Attachment #191786 for bug #325364

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 2-8 Link Here

(-)META-INF/MANIFEST.MF (-2 / +3 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %pluginName	3	Bundle-Name: %pluginName
4	Bundle-SymbolicName: org.eclipse.jst.ws.annotations.core;singleton:=true	4	Bundle-SymbolicName: org.eclipse.jst.ws.annotations.core;singleton:=true
5	Bundle-Version: 1.0.0.qualifier	5	Bundle-Version: 1.1.0.qualifier
6	Bundle-Localization: plugin	6	Bundle-Localization: plugin
7	Bundle-RequiredExecutionEnvironment: J2SE-1.5	7	Bundle-RequiredExecutionEnvironment: J2SE-1.5
8	Bundle-Vendor: %pluginProvider	8	Bundle-Vendor: %pluginProvider
Lines 18-23 Link Here
18	Export-Package: org.eclipse.jst.ws.annotations.core,	18	Export-Package: org.eclipse.jst.ws.annotations.core,
19	org.eclipse.jst.ws.annotations.core.initialization,	19	org.eclipse.jst.ws.annotations.core.initialization,
20	org.eclipse.jst.ws.annotations.core.processor,	20	org.eclipse.jst.ws.annotations.core.processor,
21	org.eclipse.jst.ws.annotations.core.utils	21	org.eclipse.jst.ws.annotations.core.utils,
		22	org.eclipse.jst.ws.internal.annotations.core.utils;x-friends:="org.eclipse.jst.ws.jaxws.ui"
22	Bundle-Activator: org.eclipse.jst.ws.annotations.core.AnnotationsCorePlugin	23	Bundle-Activator: org.eclipse.jst.ws.annotations.core.AnnotationsCorePlugin
23	Bundle-ActivationPolicy: lazy	24	Bundle-ActivationPolicy: lazy

Lines 19-24 Link Here

(-)src/org/eclipse/jst/ws/annotations/core/AnnotationDefinition.java (-25 / +147 lines)
19		19
20	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IConfigurationElement;	21	import org.eclipse.core.runtime.IConfigurationElement;
		22	import org.eclipse.jdt.core.IAnnotation;
		23	import org.eclipse.jdt.core.IJavaProject;
		24	import org.eclipse.jdt.core.IMemberValuePair;
		25	import org.eclipse.jdt.core.IType;
		26	import org.eclipse.jdt.core.JavaModelException;
22	import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;	27	import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;
23		28
24	/**	29	/**
Lines 46-53 Link Here
46	private static final String RESTRICTED_TO_INTERFACE_ONLY = "INTERFACE_ONLY";	51	private static final String RESTRICTED_TO_INTERFACE_ONLY = "INTERFACE_ONLY";
47	private static final String RESTRICTED_TO_ENUM_ONLY = "ENUM_ONLY";	52	private static final String RESTRICTED_TO_ENUM_ONLY = "ENUM_ONLY";
48		53
49	private static final String ELEM_TARGET_FILTER = "targetFilter"; //$NON-NLS-1$	54	private static final String ELEM_TARGET_FILTER = "targetFilter"; //$NON-NLS-1$
50	private static final String ATT_TARGET = "target"; //$NON-NLS-1$	55	private static final String ATT_TARGET = "target"; //$NON-NLS-1$
51		56
52	private IConfigurationElement configurationElement;	57	private IConfigurationElement configurationElement;
53	private String category;	58	private String category;
Lines 61-66 Link Here
61	private boolean classOnly;	66	private boolean classOnly;
62	private boolean enumOnly;	67	private boolean enumOnly;
63		68
		69	private IType annotationType;
		70	private List<ElementType> annotationTypeTargets;
		71	private IJavaProject javaProject;
		72	private Boolean deprecated;
		73
64	/**	74	/**
65	* Constructs an <code>AnnotationDefinition</code> using information from the	75	* Constructs an <code>AnnotationDefinition</code> using information from the
66	* <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code> extension point and category name.	76	* <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code> extension point and category name.
Lines 133-148 Link Here
133	* <code>annotation<annotation> element in the <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>	143	* <code>annotation<annotation> element in the <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>
134	* extension point.	144	* extension point.
135	*	145	*
136	* @return the annotation class	146	* @return the annotation class or null if not found.
		147	* @deprecated As of 1.1 replaced by {@link #getAnnotationType()}
137	*/	148	*/
138	@SuppressWarnings("unchecked")	149	@SuppressWarnings("unchecked")
		150	@Deprecated
139	public Class<? extends java.lang.annotation.Annotation> getAnnotationClass() {	151	public Class<? extends java.lang.annotation.Annotation> getAnnotationClass() {
140	if (annotationClass == null) {	152	if (annotationClass == null) {
141	try {	153	try {
142	Class<?> aClass = Class.forName(annotationClassName);	154	Class<?> aClass = Class.forName(annotationClassName);
143	if (aClass.isAnnotation()) {	155	if (aClass.isAnnotation()) {
144	annotationClass = (Class<java.lang.annotation.Annotation>)Class.forName(	156	annotationClass = (Class<java.lang.annotation.Annotation>) Class.forName(annotationClassName);
145	annotationClassName);
146	}	157	}
147	} catch(ClassNotFoundException cnfe) {	158	} catch(ClassNotFoundException cnfe) {
148	AnnotationsCorePlugin.log(cnfe);	159	AnnotationsCorePlugin.log(cnfe);
Lines 152-157 Link Here
152	}	163	}
153		164
154	/**	165	/**
		166	* Returns the annotation type as specified by the <code>class</code> attribute of the
		167	* <code>annotation<annotation> element in the <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>
		168	* extension point.
		169	*
		170	* @return the <code>org.eclipse.jdt.core.IType</code> which represents an annotation type or null if the java project
		171	* has not been set, if the type cannot be found or if the type does not represent an annotation type.
		172	*
		173	* @see #setJavaProject(IJavaProject)
		174	* @since 1.1
		175	*/
		176	public IType getAnnotationType() {
		177	if (annotationType == null) {
		178	try {
		179	if (javaProject != null) {
		180	IType type = javaProject.findType(annotationClassName);
		181	if (type != null && type.isAnnotation()) {
		182	annotationType = type;
		183	}
		184	}
		185	} catch (JavaModelException jme) {
		186	AnnotationsCorePlugin.log(jme.getStatus());
		187	}
		188	}
		189	return annotationType;
		190	}
		191
		192	/**
155	* Returns a list of {@link ElementType} that specify the Java elements to which the annotation	193	* Returns a list of {@link ElementType} that specify the Java elements to which the annotation
156	* can be applied.	194	* can be applied.
157	* <p>	195	* <p>
Lines 162-189 Link Here
162	* the annotation.	200	* the annotation.
163	* </p>	201	* </p>
164	* @return a list of element types.	202	* @return a list of element types.
		203	* @deprecated as of 1.1 replaced by {@link #getAnnotationTypeTargets()}
165	*/	204	*/
		205	@Deprecated
166	public List<ElementType> getTargets() {	206	public List<ElementType> getTargets() {
167	if (targets == null) {	207	if (targets == null) {
168	targets = new LinkedList<ElementType>();	208	targets = new LinkedList<ElementType>();
169		209
170	Class<? extends java.lang.annotation.Annotation> annotation = getAnnotationClass();	210	Class<? extends java.lang.annotation.Annotation> annotation = getAnnotationClass();
171	if (annotation != null) {	211	if (annotation != null) {
172	Target target = annotation.getAnnotation(Target.class);	212	Target target = annotation.getAnnotation(Target.class);
173	if (target != null) {	213	if (target != null) {
174	targets.addAll(Arrays.asList(target.value()));	214	targets.addAll(Arrays.asList(target.value()));
175		215
176	List<ElementType> filteredTargets = getFilteredTargets(configurationElement);	216	List<ElementType> filteredTargets = getFilteredTargets(configurationElement);
177	if (targets.containsAll(filteredTargets) && filteredTargets.size() < targets.size()) {	217	if (targets.containsAll(filteredTargets) && filteredTargets.size() < targets.size()) {
178	targets.removeAll(filteredTargets);	218	targets.removeAll(filteredTargets);
179	}	219	}
180	}	220	}
181	}	221	}
182	}	222	}
183	return targets;	223	return targets;
184	}	224	}
185		225
186	/**	226	/**
		227	* Returns a list of {@link ElementType} that specify the Java elements to which the annotation can be applied.
		228	* <p>
		229	* The element types are retrieved from the annotations
		230	* {@link java.lang.annotation.Target} meta-annotation type. This list can
		231	* be filtered using the <code>targetFilter</code> element on the
		232	* <code>org.eclipse.jst.ws.annotations.core.annotationDefinition</code>
		233	* extension point when defining the annotation.
		234	* </p>
		235	* @return a list of element types or null if the java project has not been set or if the annotation type cannot be
		236	* found.
		237	* @see #setJavaProject(IJavaProject)
		238	* @since 1.1
		239	*/
		240	public List<ElementType> getAnnotationTypeTargets() {
		241	if (annotationTypeTargets == null) {
		242	annotationTypeTargets = new LinkedList<ElementType>();
		243	try {
		244	IType type = getAnnotationType();
		245	if (type != null) {
		246	IAnnotation target = type.getAnnotation(Target.class.getCanonicalName());
		247	if (!target.exists()) {
		248	target = type.getAnnotation(Target.class.getSimpleName());
		249	}
		250	if (target.exists()) {
		251	IMemberValuePair[] memberValuePairs = target.getMemberValuePairs();
		252	for (IMemberValuePair memberValuePair : memberValuePairs) {
		253	Object value = memberValuePair.getValue();
		254	if (value.getClass().isArray() && value.getClass().getComponentType().equals(String.class)) {
		255	String[] objs = (String[]) value;
		256	for (String obj : objs) {
		257	annotationTypeTargets.add(ElementType.valueOf(obj.substring(obj.lastIndexOf('.') + 1)));
		258	}
		259	} else {
		260	annotationTypeTargets.add(ElementType.valueOf(value.toString().substring(value.toString().lastIndexOf('.') + 1)));
		261	}
		262	}
		263	}
		264	List<ElementType> filteredTargets = getFilteredTargets(configurationElement);
		265	if (annotationTypeTargets.containsAll(filteredTargets) && filteredTargets.size() < annotationTypeTargets.size()) {
		266	annotationTypeTargets.removeAll(filteredTargets);
		267	}
		268	}
		269	} catch (JavaModelException jme) {
		270	AnnotationsCorePlugin.log(jme.getStatus());
		271	}
		272	}
		273	return annotationTypeTargets;
		274	}
		275
		276	/**
187	* Returns the annotations attribute initializer as specified in the	277	* Returns the annotations attribute initializer as specified in the
188	* <code>org.eclipse.jst.ws.annotations.core.annotationInitializer</code> extension point or null if no	278	* <code>org.eclipse.jst.ws.annotations.core.annotationInitializer</code> extension point or null if no
189	* initializer can be found.	279	* initializer can be found.
Lines 196-203 Link Here
196	IConfigurationElement configurationElement =	286	IConfigurationElement configurationElement =
197	AnnotationsManager.getAnnotationInitializerCache().get(getAnnotationClassName());	287	AnnotationsManager.getAnnotationInitializerCache().get(getAnnotationClassName());
198	if (configurationElement != null) {	288	if (configurationElement != null) {
199	annotationInitializer = (IAnnotationAttributeInitializer)configurationElement	289	annotationInitializer = (IAnnotationAttributeInitializer)configurationElement.createExecutableExtension(ATT_CLASS);
200	.createExecutableExtension(ATT_CLASS);
201	}	290	}
202	} catch (CoreException ce) {	291	} catch (CoreException ce) {
203	AnnotationsCorePlugin.log(ce.getStatus());	292	AnnotationsCorePlugin.log(ce.getStatus());
Lines 206-222 Link Here
206	return annotationInitializer;	295	return annotationInitializer;
207	}	296	}
208		297
209	private List<ElementType> getFilteredTargets(IConfigurationElement configurationElement) {	298	private List<ElementType> getFilteredTargets(IConfigurationElement configurationElement) {
210	List<ElementType> targets = new ArrayList<ElementType>(7);	299	List<ElementType> targets = new ArrayList<ElementType>(7);
211	try {	300	try {
212	IConfigurationElement[] deprecatedTargets = configurationElement.getChildren(ELEM_TARGET_FILTER);	301	IConfigurationElement[] deprecatedTargets = configurationElement.getChildren(ELEM_TARGET_FILTER);
213	for (IConfigurationElement deprecatedTargetElement : deprecatedTargets) {	302	for (IConfigurationElement deprecatedTargetElement : deprecatedTargets) {
214	String target = AnnotationsManager.getAttributeValue(deprecatedTargetElement, ATT_TARGET);	303	String target = AnnotationsManager.getAttributeValue(deprecatedTargetElement, ATT_TARGET);
215	targets.add(ElementType.valueOf(target));	304	targets.add(ElementType.valueOf(target));
216	}	305	}
217	} catch (IllegalArgumentException iae) {	306	} catch (IllegalArgumentException iae) {
218	AnnotationsCorePlugin.log(iae);	307	AnnotationsCorePlugin.log(iae);
219	}	308	}
220	return targets;	309	return targets;
221	}	310	}
		311
		312	boolean isDeprecated() {
		313	if (deprecated == null) {
		314	IType type = getAnnotationType();
		315	if (type != null) {
		316	IAnnotation annotation = type.getAnnotation(Deprecated.class.getCanonicalName());
		317	if (!annotation.exists()) {
		318	annotation = type.getAnnotation(Deprecated.class.getSimpleName());
		319	}
		320	deprecated = annotation.exists();
		321	} else {
		322	deprecated = true;
		323	}
		324	}
		325	return deprecated;
		326	}
		327
		328	/**
		329	* Sets the <code>org.eclipse.jdt.core.IJavaProject</code> which is used to find the
		330	* annotation type.
		331	*
		332	* @see {@link #getAnnotationType()}
		333	* @see {@link #getAnnotationTypeTargets()}
		334	* @since 1.1
		335	*/
		336	public void setJavaProject(IJavaProject javaProject) {
		337	if (this.javaProject == null \|\| !this.javaProject.equals(javaProject)) {
		338	this.javaProject = javaProject;
		339	this.annotationType = null;
		340	this.annotationTypeTargets = null;
		341	this.deprecated = null;
		342	}
		343	}
222	}	344	}

Lines 12-17 Link Here

(-)src/org/eclipse/jst/ws/annotations/core/AnnotationsCore.java (-3 / +42 lines)
12		12
13	import java.util.List;	13	import java.util.List;
14		14
		15	import org.eclipse.jdt.core.IField;
		16	import org.eclipse.jdt.core.JavaModelException;
15	import org.eclipse.jdt.core.dom.AST;	17	import org.eclipse.jdt.core.dom.AST;
16	import org.eclipse.jdt.core.dom.ArrayInitializer;	18	import org.eclipse.jdt.core.dom.ArrayInitializer;
17	import org.eclipse.jdt.core.dom.BooleanLiteral;	19	import org.eclipse.jdt.core.dom.BooleanLiteral;
Lines 174-181 Link Here
174	* @param value an object representing the <code>enum</code> value.	176	* @param value an object representing the <code>enum</code> value.
175	* @return a new member value pair with the given name and value.	177	* @return a new member value pair with the given name and value.
176	*/	178	*/
177	public static MemberValuePair createEnumMemberValuePair(AST ast, String className, String name,	179	public static MemberValuePair createEnumMemberValuePair(AST ast, String className, String name, Object value) {
178	Object value) {	180	if (value instanceof IField) {
		181	return AnnotationsCore.createMemberValuePair(ast, name, createEnumLiteral(ast, className, (IField) value));
		182	}
179	return AnnotationsCore.createMemberValuePair(ast, name, createEnumLiteral(ast, className, value));	183	return AnnotationsCore.createMemberValuePair(ast, name, createEnumLiteral(ast, className, value));
180	}	184	}
181		185
Lines 241-247 Link Here
241	*	245	*
242	* @param ast the {@link AST} that will be used to create the qualified name.	246	* @param ast the {@link AST} that will be used to create the qualified name.
243	* @param className the fully qualified name of the enclosing class.	247	* @param className the fully qualified name of the enclosing class.
244	* @param value sn object representing the <code>enum</code> value.	248	* @param value an object representing the <code>enum</code> value.
245	* @return a new qualified name.	249	* @return a new qualified name.
246	*/	250	*/
247	public static QualifiedName createEnumLiteral(AST ast, String className, Object value) {	251	public static QualifiedName createEnumLiteral(AST ast, String className, Object value) {
Lines 267-272 Link Here
267	}	271	}
268		272
269	/**	273	/**
		274	* Creates a new {@link QualifiedName} to represent an <code>enum</code> literal value.
		275	*
		276	* @param ast the {@link AST} that will be used to create the qualified name.
		277	* @param className the fully qualified name of the enclosing class.
		278	* @param value a {@link org.eclipse.jdt.core.IField} where <code>isEnumConstant()</code> is <code>true</code>.
		279	* @return a new qualified name.
		280	* @throws JavaModelException
		281	* @since 1.1
		282	*/
		283	public static QualifiedName createEnumLiteral(AST ast, String className, IField enumConstant) {
		284	QualifiedName enumName = null;
		285	SimpleName enumClassName = ast.newSimpleName(enumConstant.getDeclaringType().getElementName());
		286	SimpleName enumLiteral = ast.newSimpleName(enumConstant.getElementName());
		287	try {
		288	if (enumConstant.getDeclaringType().isMember()) {
		289	Name enumEnclosingClassName = null;
		290	String enclosingClassName = enumConstant.getDeclaringType().getDeclaringType().getFullyQualifiedName();
		291	if (enclosingClassName.equals(className)) {
		292	enumEnclosingClassName = ast.newSimpleName(enumConstant.getDeclaringType().getDeclaringType().getElementName());
		293	} else {
		294	enumEnclosingClassName = ast.newName(enclosingClassName);
		295	}
		296	QualifiedName qualifiedName = ast.newQualifiedName(enumEnclosingClassName, enumClassName);
		297	enumName = ast.newQualifiedName(qualifiedName, enumLiteral);
		298	} else {
		299	Name qualifiedName = ast.newName(enumConstant.getDeclaringType().getFullyQualifiedName());
		300	enumName = ast.newQualifiedName(qualifiedName, enumLiteral);
		301	}
		302	} catch (JavaModelException jme) {
		303	AnnotationsCorePlugin.log(jme.getStatus());
		304	}
		305	return enumName;
		306	}
		307
		308	/**
270	* Creates a new {@link TypeLiteral}.	309	* Creates a new {@link TypeLiteral}.
271	*	310	*
272	* @param ast the {@link AST} that will be used to create the {@link TypeLiteral}.	311	* @param ast the {@link AST} that will be used to create the {@link TypeLiteral}.




    private static final String ATT_NAME = "name"; //$NON-NLS-1$
    private static final String ATT_CATEGORY = "category"; //$NON-NLS-1$

    //	private static final String ELEM_TARGET_FILTER = "targetFilter"; //$NON-NLS-1$
    //	private static final String ATT_TARGET = "target"; //$NON-NLS-1$

    private AnnotationsManager() {
    }


    }

    /**
     * Returns a list of all the contributed annotations that target the given {@link org.eclipse.jdt.core.IJavaElement}.
     *
     * @param element one of
     * <li>org.eclipse.jdt.core.IPackageDeclaration</li>
     * <li>org.eclipse.jdt.core.IType</li>
     * <li>org.eclipse.jdt.core.IField</li>
     * <li>org.eclipse.jdt.core.IMethod</li>
     * <li>org.eclipse.jdt.core.ILocalVariable</li>
     *
     * @return a list of types which represent annotation types.
     * @since 1.1
     */
    public static List<IType> getAnnotationTypes(IJavaElement javaElement) {
        List<IType> annotations = new ArrayList<IType>();

        try {
            List<AnnotationDefinition> annotationDefinitions = getAllAnnotationsForElement(javaElement);

            filterAnnotationsList(javaElement, annotationDefinitions);

            for (AnnotationDefinition annotationDefinition : annotationDefinitions) {
                IType type = annotationDefinition.getAnnotationType();
                if (type != null) {
                    annotations.add(type);
                }
            }
        } catch (JavaModelException jme) {
            AnnotationsCorePlugin.log(jme.getStatus());
        }
        return annotations;
    }

    /**
     * Returns a list of all the contributed {@link java.lang.annotation.Annotation} that target the given java element type.
     *
     * @param element one of

     * <li>org.eclipse.jdt.core.ILocalVariable</li>
     *
     * @return a list of annotations.
     * @deprecated As of 1.1 replaced by {@link #getAnnotationTypes(IJavaElement)}}
     */
    @Deprecated
    public static List<Class<? extends Annotation>> getAnnotations(IJavaElement javaElement) {
        List<Class<? extends Annotation>> annotations = new ArrayList<Class<? extends Annotation>>();


    }

    private static synchronized Map<String, AnnotationDefinition> getAnnotationToClassNameDefinitionMap() {

        if (annotationClassNameToDefinitionMap == null) {
            List<AnnotationDefinition> annotationDefinitions = getAnnotations();

            annotationClassNameToDefinitionMap = new HashMap<String, AnnotationDefinition>();

            for (AnnotationDefinition annotationDefinition : annotationDefinitions) {
                if (annotationDefinition.getAnnotationClassName() != null) {
                    annotationClassNameToDefinitionMap.put(annotationDefinition.getAnnotationClassName(), annotationDefinition);
                }
            	}
            }
        }
        return annotationClassNameToDefinitionMap;

    }

    /**
     * Returns the {@link AnnotationDefinition} for the given {@link org.eclipse.jdt.core.IType}
     * or null if no annotation definition can be found.
     *
     * @param annotationType an <code>org.eclipse.jdt.core.IType</code> which represents an annotation type.
     * @return the annotation definition for the <code>org.eclipse.jdt.core.IType</code>.
     * @since 1.1
     */
    public static AnnotationDefinition getAnnotationDefinitionForType(IType annotationType) {
        return getAnnotationToClassNameDefinitionMap().get(annotationType.getFullyQualifiedName());
    }

    /**
     * Returns the {@link IAnnotationAttributeInitializer} for the given {@link org.eclipse.jdt.core.dom.Name}
     * or null if none can be found.
     * @param name a {@link SimpleName} or {@link QualifiedName} for the annotation to search for.

        if (annotationCategoryCache != null) {
            return annotationCategoryCache;
        }

        annotationCategoryCache = new HashMap<String, String>();

        IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(

        if (annotationInitializerCache != null) {
            return annotationInitializerCache;
        }

        annotationInitializerCache = new HashMap<String, IConfigurationElement>();

        IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(

        return ""; //$NON-NLS-1$
    }

    private static List<AnnotationDefinition> getAllAnnotationsForElement(IJavaElement javaElement) throws JavaModelException {
    throws JavaModelException {

        if (javaElement instanceof IPackageDeclaration) {
            return getAnnotationsForElementType(javaElement, ElementType.PACKAGE);
        }

        if (javaElement instanceof IType) {
            IType type = (IType) javaElement;
            if (type.isAnnotation()) {
                return getAnnotationsForElementType(javaElement, ElementType.ANNOTATION_TYPE);
            }
            return getAnnotationsForElementType(javaElement, ElementType.TYPE);
        }

        if (javaElement instanceof IField) {
            return getAnnotationsForElementType(javaElement, ElementType.FIELD);
        }

        if (javaElement instanceof IMethod) {
            return getAnnotationsForElementType(javaElement, ElementType.METHOD);
        }

        if (javaElement instanceof ILocalVariable) {
            return getAnnotationsForElementType(javaElement, ElementType.PARAMETER);
        }

        if (javaElement instanceof IAnnotation) {
            return getAnnotationsForElementType(javaElement, ElementType.ANNOTATION_TYPE);
        }

        return Collections.emptyList();
    }

    private static List<AnnotationDefinition> getAnnotationsForElementType(IJavaElement javaElement, ElementType elementType) {
        List<AnnotationDefinition> annotationDefinitions = new ArrayList<AnnotationDefinition>();

        if (annotationCache == null) {

        }

        for (AnnotationDefinition annotationDefinition : annotationCache) {
            annotationDefinition.setJavaProject(javaElement.getJavaProject());

            if (annotationDefinition.getAnnotationTypeTargets().contains(elementType) &&
                    !annotationDefinition.isDeprecated()) {
                annotationDefinitions.add(annotationDefinition);
            }
        }

                    annotationIter.remove();
                }
                if (method.isConstructor()
                        && !annotationDefinition.getAnnotationTypeTargets().contains(ElementType.CONSTRUCTOR)) {
                    annotationIter.remove();
                }


        }
        return false;
    }

    //TODO Move the Deprecated option to preferences
    private static boolean isDeprecated(AnnotationDefinition annotationDefinition) {
        Class<?> annotationClass = annotationDefinition.getAnnotationClass();
        return annotationClass.getAnnotation(java.lang.Deprecated.class) != null;
    }
}




import java.util.List;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.MemberValuePair;

 */
public abstract class AnnotationAttributeInitializer implements IAnnotationAttributeInitializer {

	protected static final String MISSING_IDENTIFER = "$missing$";

	protected AnnotationAttributeInitializer() {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer#getMemberValuePairs(org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.dom.AST, java.lang.Class)
	 */
	@Deprecated
	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast,  Class<? extends Annotation> annotationClass) {
		return Collections.emptyList();
	}

	/**
	 * @see org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer#getMemberValuePairs(org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.dom.AST, java.lang.Class)
	 * @since 1.1
	 */
	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType type) {
	    return Collections.emptyList();
    }

	/* (non-Javadoc)
	 * @see org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer#getCompletionProposalsForMemberValuePair(org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.dom.MemberValuePair)
	 */
	public List<ICompletionProposal> getCompletionProposalsForMemberValuePair(IJavaElement javaElement,
			MemberValuePair memberValuePair) {
		return Collections.emptyList();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer#getCompletionProposalsForSingleMemberAnnotation(org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.dom.SingleMemberAnnotation)
	 */
	public List<ICompletionProposal> getCompletionProposalsForSingleMemberAnnotation(IJavaElement javaElement,
			SingleMemberAnnotation singleMemberAnnotation) {
		return Collections.emptyList();
	}

	protected CompletionProposal createCompletionProposal(String proposal, Expression value) {
		Image image = PlatformUI.getWorkbench().getSharedImages().getImage(org.eclipse.ui.ISharedImages.IMG_OBJ_FILE);
		return createCompletionProposal(proposal, value, image, proposal);
	}

	protected CompletionProposal createCompletionProposal(String proposal, Expression value, Image image, String displayString) {
		int replacementOffset = value.getStartPosition();
		int replacementLength = 0;
		if (value.toString().equals(MISSING_IDENTIFER)) {
			if (proposal.charAt(0) != '\"') {
				proposal = "\"" + proposal;
			}
			if (proposal.charAt(proposal.length() - 1) != '\"') {
				proposal = proposal + "\"";
			}
		} else {
			replacementOffset += 1;
			replacementLength = value.getLength() - 2;
		}

		return new CompletionProposal(proposal, replacementOffset, replacementLength, proposal.length(),
				image, displayString, null, null);
	}

}

Lines 15-24 Link Here

(-)src/org/eclipse/jst/ws/annotations/core/initialization/DefaultsAnnotationAttributeInitializer.java (-4 / +84 lines)
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16	import java.util.List;	16	import java.util.List;
17		17
		18	import org.eclipse.jdt.core.IField;
18	import org.eclipse.jdt.core.IJavaElement;	19	import org.eclipse.jdt.core.IJavaElement;
		20	import org.eclipse.jdt.core.IMemberValuePair;
		21	import org.eclipse.jdt.core.IMethod;
		22	import org.eclipse.jdt.core.IType;
		23	import org.eclipse.jdt.core.JavaModelException;
		24	import org.eclipse.jdt.core.Signature;
19	import org.eclipse.jdt.core.dom.AST;	25	import org.eclipse.jdt.core.dom.AST;
20	import org.eclipse.jdt.core.dom.MemberValuePair;	26	import org.eclipse.jdt.core.dom.MemberValuePair;
21	import org.eclipse.jst.ws.annotations.core.AnnotationsCore;	27	import org.eclipse.jst.ws.annotations.core.AnnotationsCore;
		28	import org.eclipse.jst.ws.annotations.core.AnnotationsCorePlugin;
		29	import org.eclipse.jst.ws.internal.annotations.core.utils.SignatureUtils;
22		30
23	/**	31	/**
24	* Constructs {@link MemberValuePair} from the defaults found in the given {@link java.lang.annotation.Annotation}.	32	* Constructs {@link MemberValuePair} from the defaults found in the given {@link java.lang.annotation.Annotation}.
Lines 40-52 Link Here
40	* @see org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer#getMemberValuePairs(org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.dom.AST, java.lang.Class)	48	* @see org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer#getMemberValuePairs(org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.dom.AST, java.lang.Class)
41	*/	49	*/
42	@Override	50	@Override
43	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast,	51	@Deprecated
44	Class<? extends Annotation> annotationClass) {	52	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, Class<? extends Annotation> annotationClass) {
45	return getMemberValuePairs(ast, annotationClass);	53	return getMemberValuePairs(ast, annotationClass);
46	}	54	}
47		55
48	private List<MemberValuePair> getMemberValuePairs(AST ast,	56	@Override
49	Class<? extends Annotation> annotationClass) {	57	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType type) {
		58	return interalGetMemberValuePairs(javaElement, ast, type);
		59	}
		60
		61	private List<MemberValuePair> interalGetMemberValuePairs(IJavaElement javaElement, AST ast, IType type) {
		62	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
		63
		64	try {
		65	IMethod[] methods = type.getMethods();
		66	for (IMethod method : methods) {
		67	String name = method.getElementName();
		68	String returnType = method.getReturnType();
		69	IMemberValuePair defaultValue = method.getDefaultValue();
		70	if (defaultValue != null) {
		71	if (SignatureUtils.isString(returnType)) {
		72	memberValuePairs.add(AnnotationsCore.createStringMemberValuePair(ast,
		73	name, defaultValue.getValue().toString()));
		74	}
		75
		76	if (SignatureUtils.isBoolean(returnType)) {
		77	memberValuePairs.add(AnnotationsCore.createBooleanMemberValuePair(ast,
		78	name, Boolean.parseBoolean(defaultValue.getValue().toString())));
		79	}
		80
		81	int signatureKind = Signature.getTypeSignatureKind(returnType);
		82	if (signatureKind == Signature.BASE_TYPE_SIGNATURE) {
		83	if (returnType.charAt(0) == Signature.C_BYTE
		84	\|\| returnType.charAt(0) == Signature.C_SHORT
		85	\|\| returnType.charAt(0) == Signature.C_INT
		86	\|\| returnType.charAt(0) == Signature.C_LONG
		87	\|\| returnType.charAt(0) == Signature.C_FLOAT
		88	\|\| returnType.charAt(0) == Signature.C_DOUBLE) {
		89	memberValuePairs.add(AnnotationsCore.createNumberMemberValuePair(ast, name, defaultValue.getValue().toString()));
		90	}
		91	}
		92
		93	if (SignatureUtils.isArray(returnType)) {
		94	memberValuePairs.add(AnnotationsCore.createArrayMemberValuePair(ast, method.getElementName(),
		95	(Object[]) defaultValue.getValue()));
		96	}
		97
		98	if (SignatureUtils.isEnum(method)) {
		99	if (defaultValue.getValueKind() == IMemberValuePair.K_QUALIFIED_NAME) {
		100	String value = defaultValue.getValue().toString();
		101	String enumName = value.substring(0, value.lastIndexOf("."));
		102	String constant = value.substring(value.lastIndexOf(".") + 1, value.length());
		103	IType enumType = javaElement.getJavaProject().findType(enumName);
		104	if (enumType != null && enumType.isEnum()) {
		105	IField[] fields = enumType.getFields();
		106	for (IField field : fields) {
		107	if (field.isEnumConstant() && field.getElementName().equals(constant)) {
		108	memberValuePairs.add(AnnotationsCore.createEnumMemberValuePair(ast,
		109	method.getDeclaringType().getFullyQualifiedName(), name, field));
		110	}
		111	}
		112	}
		113	}
		114	}
		115
		116	if (SignatureUtils.isClass(returnType)) {
		117	memberValuePairs.add(AnnotationsCore.createTypeMemberValuePair(ast, name,
		118	defaultValue.getValue()));
		119	}
		120	}
		121	}
122	} catch (JavaModelException jme) {
123	AnnotationsCorePlugin.log(jme.getStatus());
124	}
125
126	return memberValuePairs;
127	}
128
129	private List<MemberValuePair> getMemberValuePairs(AST ast, Class<? extends Annotation> annotationClass) {
50	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	130	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
51		131
52	Method[] declaredMethods = annotationClass.getDeclaredMethods();	132	Method[] declaredMethods = annotationClass.getDeclaredMethods();




import java.util.List;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.MemberValuePair;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;

     * @param annotationClass the {@link java.lang.annotation.Annotation} class which may be
     * used to query the declared members of the annotation type and the members default values.
     * @return a list of member value pairs.
     * @deprecated as of 1.1 replaced by {@link IAnnotationAttributeInitializer2#getMemberValuePairs(IJavaElement, AST, IType)}
     */
    @Deprecated
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast,
            Class<? extends java.lang.annotation.Annotation> annotationClass);

    /**
     * Returns a list of {@link MemberValuePair} that may be added to a {@link NormalAnnotation}.
     * @param javaElement the java element on which the annotation is declared.
     * @param ast the <code>AST</code> with which to create the member value pairs.
     * @param type the {@link org.eclipse.jdt.core.IType} which represents an annotation type,.
     * @return a list of member value pairs.
     * @since 1.1
     */
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType type);

    /**
     * Used to provide a list of {@link ICompletionProposal} for a {@link MemberValuePair} value.
     * @param javaElement the java element on which the annotation is declared.
     * @param memberValuePair the member value pair in which content assist was invoked.

Lines 317-325 Link Here

(-)src/org/eclipse/jst/ws/annotations/core/utils/AnnotationUtils.java (-1 / +2 lines)
317	final String annotationSimpleName = qualifiedName.substring(qualifiedName.lastIndexOf(".") + 1);	317	final String annotationSimpleName = qualifiedName.substring(qualifiedName.lastIndexOf(".") + 1);
318	final List<String> occurences = new ArrayList<String>();	318	final List<String> occurences = new ArrayList<String>();
319	AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForClass(qualifiedName);	319	AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForClass(qualifiedName);
		320	annotationDefinition.setJavaProject(javaElement.getJavaProject());
320	List<ElementType> elementTypes = Collections.emptyList();	321	List<ElementType> elementTypes = Collections.emptyList();
321	if (annotationDefinition != null) {	322	if (annotationDefinition != null) {
322	elementTypes = annotationDefinition.getTargets();	323	elementTypes = annotationDefinition.getAnnotationTypeTargets();
323	}	324	}
324	for (ElementType elementType : elementTypes) {	325	for (ElementType elementType : elementTypes) {
325	if (elementType == ElementType.PACKAGE) {	326	if (elementType == ElementType.PACKAGE) {




/*******************************************************************************
 * Copyright (c) 2011 Shane Clarke.
 * 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:
 *    Shane Clarke - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.internal.annotations.core.utils;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;

public final class SignatureUtils {

    private SignatureUtils() {
    }

    public static boolean isString(String returnType) {
        int signatureKind = Signature.getTypeSignatureKind(returnType);
        if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
            if (returnType.charAt(0) == Signature.C_RESOLVED) {
                return Signature.toString(returnType).equals(java.lang.String.class.getCanonicalName());
            }
            if (returnType.charAt(0) == Signature.C_UNRESOLVED) {
                return Signature.toString(returnType).equals(java.lang.String.class.getSimpleName());
            }
        }
        return false;
    }

    public static boolean isClass(String returnType) {
        int signatureKind = Signature.getTypeSignatureKind(returnType);
        if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
            if (returnType.charAt(0) == Signature.C_RESOLVED) {
                returnType = Signature.getTypeErasure(returnType);
                return Signature.toString(returnType).equals(java.lang.Class.class.getCanonicalName());
            }
            if (returnType.charAt(0) == Signature.C_UNRESOLVED) {
                returnType = Signature.getTypeErasure(returnType);
                return Signature.toString(returnType).equals(java.lang.Class.class.getSimpleName());
            }
        }
        return false;
    }

    public static boolean isBoolean(String returnType) {
        int signatureKind = Signature.getTypeSignatureKind(returnType);
        if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
            if (returnType.charAt(0) == Signature.C_RESOLVED) {
                return Signature.toString(returnType).equals(java.lang.Boolean.class.getCanonicalName());
            }
            if (returnType.charAt(0) == Signature.C_UNRESOLVED) {
                return Signature.toString(returnType).equals(java.lang.Boolean.class.getSimpleName());
            }
        }
        if (signatureKind == Signature.BASE_TYPE_SIGNATURE) {
            return returnType.charAt(0) == Signature.C_BOOLEAN;
        }
        return false;
    }

    public static boolean isArray(String returnType) {
        return Signature.getTypeSignatureKind(returnType) == Signature.ARRAY_TYPE_SIGNATURE;
    }

    public static boolean isPrimitive(String returnType) {
        return Signature.getTypeSignatureKind(returnType) == Signature.BASE_TYPE_SIGNATURE;
    }

    public static boolean isEnum(IMethod method) throws JavaModelException {
        return getEnumReturnType(method) != null;
    }

    public static IType getEnumReturnType(IMethod method) throws JavaModelException {
        String returnType = method.getReturnType();
        int signatureKind = Signature.getTypeSignatureKind(returnType);
        if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
            if (returnType.charAt(0) == Signature.C_RESOLVED) {
                IType type = method.getJavaProject().findType(Signature.toString(returnType));
                if (type != null && type.isEnum()) {
                    return type;
                }
            }
        }
        return null;
    }

    public static String[] getEnumConstantsNames(IType enumType) throws JavaModelException {
        if (enumType.isEnum()) {
            List<String> enumConstants = new ArrayList<String>();
            IField[] fields = getEnumConstants(enumType);
            for (IField field : fields) {
                enumConstants.add(field.getElementName());
            }
            return enumConstants.toArray(new String[enumConstants.size()]);
        }
        return new String[] {};
    }

    public static IField[] getEnumConstants(IType enumType) throws JavaModelException {
        if (enumType.isEnum()) {
            List<IField> enumConstants = new ArrayList<IField>();
            IField[] fields = enumType.getFields();
            for (IField field : fields) {
                if (field.isEnumConstant()) {
                    enumConstants.add(field);
                }
            }
            return enumConstants.toArray(new IField[enumConstants.size()]);
        }
        return new IField[] {};
    }


}

Lines 46-52 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
46	org.eclipse.ui.console;bundle-version="[3.3.0,4.0.0)",	46	org.eclipse.ui.console;bundle-version="[3.3.0,4.0.0)",
47	org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)",	47	org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)",
48	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",	48	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",
49	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	49	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
50	org.eclipse.jst.ws.jaxws.core;bundle-version="[1.0.0,1.1.0)",	50	org.eclipse.jst.ws.jaxws.core;bundle-version="[1.0.0,1.1.0)",
51	org.eclipse.wst.command.env.core;bundle-version="[1.0.204,1.1.0)",	51	org.eclipse.wst.command.env.core;bundle-version="[1.0.204,1.1.0)",
52	javax.jws;bundle-version="[2.0.0,2.1.0)",	52	javax.jws;bundle-version="[2.0.0,2.1.0)",




import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
import org.eclipse.jdt.ui.CodeStyleConfiguration;
import org.eclipse.jdt.ui.SharedASTProvider;
import org.eclipse.jst.ws.annotations.core.AnnotationDefinition;
import org.eclipse.jst.ws.annotations.core.AnnotationsCore;
import org.eclipse.jst.ws.annotations.core.AnnotationsManager;
import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;

        } else {
            List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();

            AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForClass(WebService.class.getCanonicalName());
            IAnnotationAttributeInitializer annotationAttributeInitializer = annotationDefinition.getAnnotationAttributeInitializer();
                getAnnotationAttributeInitializer();

            IType annotationType = annotationDefinition.getAnnotationType();
            if (annotationAttributeInitializer != null) {
                memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(type, ast, annotationType);
                        WebService.class);
            }

            if (model.isUseServiceEndpointInterface() && type.isClass()) {


        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();

        AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForClass(annotationClass.getCanonicalName());
        IAnnotationAttributeInitializer annotationAttributeInitializer = annotationDefinition.getAnnotationAttributeInitializer();

        IType annotationType = annotationDefinition.getAnnotationType();

        if (annotationAttributeInitializer != null) {
            memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(javaElement, ast, annotationType);
        }

        return AnnotationsCore.createNormalAnnotation(ast, annotationClass.getSimpleName(), memberValuePairs);

Lines 23-29 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
23	org.eclipse.jst.j2ee;bundle-version="[1.1.100,1.2.0)",	23	org.eclipse.jst.j2ee;bundle-version="[1.1.100,1.2.0)",
24	org.eclipse.jst.j2ee.core;bundle-version="[1.1.0,1.3.0)",	24	org.eclipse.jst.j2ee.core;bundle-version="[1.1.0,1.3.0)",
25	org.eclipse.text;bundle-version="[3.4.0,4.0.0)",	25	org.eclipse.text;bundle-version="[3.4.0,4.0.0)",
26	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	26	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
27	org.eclipse.jst.ws.jaxws.core;bundle-version="[1.0.0,1.1.0)",	27	org.eclipse.jst.ws.jaxws.core;bundle-version="[1.0.0,1.1.0)",
28	org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)",	28	org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)",
29	org.eclipse.jem;bundle-version="[2.0.0,2.1.0)",	29	org.eclipse.jem;bundle-version="[2.0.0,2.1.0)",

Lines 29-35 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
29	org.eclipse.jst.ws.creation.ui;bundle-version="[1.0.305,1.1.0)",	29	org.eclipse.jst.ws.creation.ui;bundle-version="[1.0.305,1.1.0)",
30	org.eclipse.jst.ws;bundle-version="[1.0.304,1.1.0)",	30	org.eclipse.jst.ws;bundle-version="[1.0.304,1.1.0)",
31	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",	31	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",
32	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	32	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
33	org.eclipse.jst.ws.jaxws.core;bundle-version="[1.0.0,1.1.0)",	33	org.eclipse.jst.ws.jaxws.core;bundle-version="[1.0.0,1.1.0)",
34	org.eclipse.emf.common;bundle-version="[2.4.0,3.0.0)",	34	org.eclipse.emf.common;bundle-version="[2.4.0,3.0.0)",
35	javax.wsdl;bundle-version="[1.6.2,1.7.0)",	35	javax.wsdl;bundle-version="[1.6.2,1.7.0)",

Lines 6-16 Link Here

(-)META-INF/MANIFEST.MF (-5 / +2 lines)
6	Bundle-Version: 1.0.0.qualifier	6	Bundle-Version: 1.0.0.qualifier
7	Bundle-ClassPath: .	7	Bundle-ClassPath: .
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Eclipse-RegisterBuddy: org.eclipse.jst.ws.annotations.core
10	Bundle-RequiredExecutionEnvironment: J2SE-1.5	9	Bundle-RequiredExecutionEnvironment: J2SE-1.5
11	Bundle-Activator: org.eclipse.jst.ws.internal.jaxb.core.JAXBCorePlugin	10	Bundle-Activator: org.eclipse.jst.ws.internal.jaxb.core.JAXBCorePlugin
12	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)"	11	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)",
13	Export-Package: org.eclipse.jst.ws.internal.jaxb.core	12	org.eclipse.jst.ws.annotations.core;bundle-version="1.1.0"
14	Import-Package: javax.xml.bind.annotation;version="[2.1.0,2.2.0)",
15	javax.xml.bind.annotation.adapters;version="[2.1.0,2.2.0)"
16	Bundle-ActivationPolicy: lazy	13	Bundle-ActivationPolicy: lazy




            category="jaxb.category"
            class="javax.xml.bind.annotation.XmlAccessorType"
            name="XmlAccessorType"/>
      
      <!-- TODO Reinstate when XmlAdapter issue is solved
      <annotation
            category="jaxb.category"
            class="javax.xml.bind.annotation.adapters.XmlAdapter"
            name="XmlAdapter">
      </annotation>
      -->
      
      <annotation
            category="jaxb.category"
            class="javax.xml.bind.annotation.XmlAnyAttribute"

            name="XmlValue">
      </annotation>
   </extension>

</plugin>

Lines 14-20 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
14	org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",	14	org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",
15	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",	15	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",
16	org.eclipse.ltk.ui.refactoring;bundle-version="[3.4.0,4.0.0)",	16	org.eclipse.ltk.ui.refactoring;bundle-version="[3.4.0,4.0.0)",
17	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	17	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
18	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",	18	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",
19	org.eclipse.text;bundle-version="[3.4.0,4.0.0)",	19	org.eclipse.text;bundle-version="[3.4.0,4.0.0)",
20	org.eclipse.jdt.ui;bundle-version="[3.4.0,4.0.0)"	20	org.eclipse.jdt.ui;bundle-version="[3.4.0,4.0.0)"

Lines 14-20 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
14	org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",	14	org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",
15	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",	15	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",
16	org.eclipse.ltk.ui.refactoring;bundle-version="[3.4.0,4.0.0)",	16	org.eclipse.ltk.ui.refactoring;bundle-version="[3.4.0,4.0.0)",
17	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	17	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
18	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",	18	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",
19	org.eclipse.text;bundle-version="[3.4.0,4.0.0)",	19	org.eclipse.text;bundle-version="[3.4.0,4.0.0)",
20	org.eclipse.jdt.ui;bundle-version="[3.4.0,4.0.0)"	20	org.eclipse.jdt.ui;bundle-version="[3.4.0,4.0.0)"

Lines 17-23 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
17	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",	17	org.eclipse.ltk.core.refactoring;bundle-version="[3.4.0,4.0.0)",
18	org.eclipse.ui.editors;bundle-version="[3.4.0,4.0.0)",	18	org.eclipse.ui.editors;bundle-version="[3.4.0,4.0.0)",
19	org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",	19	org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",
20	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	20	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
21	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",	21	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",
22	org.eclipse.jst.ws.jaxws.dom.runtime;bundle-version="[1.0.0,1.1.0)",	22	org.eclipse.jst.ws.jaxws.dom.runtime;bundle-version="[1.0.0,1.1.0)",
23	org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)"	23	org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)"




package org.eclipse.jst.ws.internal.jaxws.ui.annotations.initialization;

import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.VALUE;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.xml.ws.http.HTTPBinding;
import javax.xml.ws.soap.SOAPBinding;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.dom.AST;

        JAXWSUIPlugin.getDefault().getImageRegistry().put(HTTP_BINDING,
                JAXWSUIPlugin.getImageDescriptor("icons/obj16/httpbinding_obj.gif").createImage()); //$NON-NLS-1$
    }
    
    @Override
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
            Class<? extends Annotation> annotationClass) {
        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
        if (javaElement.getElementType() == IJavaElement.TYPE) {
            MemberValuePair value = AnnotationsCore.createStringMemberValuePair(ast, VALUE, getDefault()); //$NON-NLS-1$




import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.OPERATION_NAME;
import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.TARGET_NAMESPACE;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;


import org.eclipse.jst.ws.jaxws.core.utils.JDTUtils;

public class RequestWrapperAttributeInitializer extends AnnotationAttributeInitializer {
    
    @Override
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
            Class<? extends Annotation> annotationClass) {
        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
        if (javaElement.getElementType() == IJavaElement.METHOD) {
            IMethod method = (IMethod) javaElement;




import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.STYLE;
import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.USE;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;


import javax.jws.soap.SOAPBinding.Use;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.MemberValuePair;
import org.eclipse.jst.ws.annotations.core.AnnotationsCore;
import org.eclipse.jst.ws.annotations.core.initialization.AnnotationAttributeInitializer;

public class SOAPBindingAttributeInitializer extends AnnotationAttributeInitializer {
    
    @Override
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
            Class<? extends Annotation> annotationClass) {
        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();

        MemberValuePair styleValuePair = AnnotationsCore.createEnumMemberValuePair(ast,




import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.ACTION;
import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.OPERATION_NAME;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;


import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;

public class WebMethodAttributeInitializer extends AnnotationAttributeInitializer {
        
    @Override
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
            Class<? extends Annotation> annotationClass) {

        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();

        if (javaElement.getElementType() == IJavaElement.METHOD) {
            IMethod method = (IMethod) javaElement;
            IType type = method.getCompilationUnit().findPrimaryType();
            
            MemberValuePair operationValuePair = AnnotationsCore.createStringMemberValuePair(ast, 
                    OPERATION_NAME, getOperationNameValue(method));

            MemberValuePair actionValuePair = AnnotationsCore.createStringMemberValuePair(ast, 
                    ACTION, getActionValue(method));

            memberValuePairs.add(operationValuePair);
            memberValuePairs.add(actionValuePair);

        
        if (javaElement.getElementType() == IJavaElement.METHOD) {
            IMethod method = (IMethod) javaElement;
            IType type = method.getCompilationUnit().findPrimaryType();
            
            String memberValuePairName = memberValuePair.getName().getIdentifier();

            if (memberValuePairName.equals(OPERATION_NAME)) {
                completionProposals.add(createCompletionProposal(getOperationNameValue(method), 
                		memberValuePair.getValue()));
            }
            
            if (memberValuePairName.equals(ACTION)) {
                completionProposals.add(createCompletionProposal(getActionValue(method),
                		memberValuePair.getValue()));
            }


        return completionProposals;
    }

    private String getOperationNameValue(IMethod method) {
        try {
            return method.getElementName() + JAXWSUtils.accountForOverloadedMethods(method);
        } catch (JavaModelException jme) {

        return ""; //$NON-NLS-1$
    }
    
    private String getActionValue(IMethod method) {
        try {
            String methodName = method.getElementName();
            return "urn:" + methodName.substring(0, 1).toUpperCase()  //$NON-NLS-1$




import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.PART_NAME;
import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.TARGET_NAMESPACE;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.eclipse.jst.ws.jaxws.core.utils.JDTUtils;

public class WebParamAttributeInitializer extends AnnotationAttributeInitializer {
    
    @Override
    public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
            AST ast, Class<? extends Annotation> annotationClass) {

        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();


Lines 18-24 Link Here

(-)src/org/eclipse/jst/ws/internal/jaxws/ui/annotations/initialization/WebResultAttributeInitializer.java (-3 / +1 lines)
18	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.RETURN;	18	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.RETURN;
19	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.TARGET_NAMESPACE;	19	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.TARGET_NAMESPACE;
20		20
21	import java.lang.annotation.Annotation;
22	import java.util.ArrayList;	21	import java.util.ArrayList;
23	import java.util.List;	22	import java.util.List;
24		23
Lines 47-54 Link Here
47	public class WebResultAttributeInitializer extends AnnotationAttributeInitializer {	46	public class WebResultAttributeInitializer extends AnnotationAttributeInitializer {
48		47
49	@Override	48	@Override
50	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast,	49	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
51	Class<? extends Annotation> annotationClass) {
52	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	50	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
53		51
54	if (javaElement.getElementType() == IJavaElement.METHOD) {	52	if (javaElement.getElementType() == IJavaElement.METHOD) {

Lines 18-24 Link Here

(-)src/org/eclipse/jst/ws/internal/jaxws/ui/annotations/initialization/WebServiceAttributeInitializer.java (-3 / +1 lines)
18	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.SERVICE_SUFFIX;	18	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.SERVICE_SUFFIX;
19	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.TARGET_NAMESPACE;	19	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.TARGET_NAMESPACE;
20		20
21	import java.lang.annotation.Annotation;
22	import java.util.ArrayList;	21	import java.util.ArrayList;
23	import java.util.Collections;	22	import java.util.Collections;
24	import java.util.List;	23	import java.util.List;
Lines 40-47 Link Here
40	public class WebServiceAttributeInitializer extends AnnotationAttributeInitializer {	39	public class WebServiceAttributeInitializer extends AnnotationAttributeInitializer {
41		40
42	@Override	41	@Override
43	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast,	42	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
44	Class<? extends Annotation> annotationClass) {
45		43
46	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	44	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
47	if (javaElement.getElementType() == IJavaElement.TYPE) {	45	if (javaElement.getElementType() == IJavaElement.TYPE) {




 *******************************************************************************/
package org.eclipse.jst.ws.internal.jaxws.ui.views;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

import java.util.Map.Entry;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IJavaProject;
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.jdt.core.search.SearchEngine;
import org.eclipse.jdt.ui.IJavaElementSearchConstants;
import org.eclipse.jdt.ui.ISharedImages;

import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.window.Window;
import org.eclipse.jst.ws.internal.annotations.core.utils.SignatureUtils;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIMessages;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;
import org.eclipse.swt.SWT;

import org.eclipse.ui.dialogs.SelectionStatusDialog;

public class AnnotationArrayCellEditor extends DialogCellEditor {
    private IMethod method;
    private Object[] values;

    private List<Object> originalValues;

        return values;
    }

    public void setMethod(IMethod method) {
        this.method = method;
        if (updatedValues != null) {
            updatedValues.clear();

        protected Control createDialogArea(Composite parent) {
            Composite mainComposite = (Composite) super.createDialogArea(parent);

            try {
                GridLayout gridLayout = new GridLayout(3, false);
                mainComposite.setLayout(gridLayout);
            GridData gridData = new GridData(SWT.FILL, SWT.BEGINNING, false, false);
            gridData.widthHint = 800;
            mainComposite.setLayoutData(gridData);

            Composite typeComposite = new Composite(mainComposite, SWT.NONE);
            gridLayout = new GridLayout(3, false);
            typeComposite.setLayout(gridLayout);
            gridData = new GridData(SWT.FILL, SWT.BEGINNING, true, true);
            typeComposite.setLayoutData(gridData);

            final Class<?> componentType = method.getReturnType().getComponentType();
            if (componentType.isAnnotation()) {
                Label compontTypeLabel = new Label(typeComposite, SWT.NONE);
                compontTypeLabel.setText("@" + componentType.getName()); //$NON-NLS-1$
                gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
                gridData.horizontalSpan = 3;
                compontTypeLabel.setLayoutData(gridData);

                GridData gridData = new GridData(SWT.FILL, SWT.BEGINNING, false, false);
                gridData.widthHint = 800;
                mainComposite.setLayoutData(gridData);

                Composite typeComposite = new Composite(mainComposite, SWT.NONE);
                gridLayout = new GridLayout(3, false);
                typeComposite.setLayout(gridLayout);
                gridData = new GridData(SWT.FILL, SWT.BEGINNING, true, true);
                typeComposite.setLayoutData(gridData);

                final IType componentType = getComponentType(method);
                if (componentType != null) {
                    if (componentType.isAnnotation()) {
                        Label compontTypeLabel = new Label(typeComposite, SWT.NONE);
                        compontTypeLabel.setText("@" + componentType.getFullyQualifiedName()); //$NON-NLS-1$
                        gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
                        gridData.horizontalSpan = 3;
                        compontTypeLabel.setLayoutData(gridData);

                        IMethod[] methods = componentType.getMethods();
                        for (IMethod method : methods) {
                            Label label = new Label(typeComposite, SWT.NONE);
                            label.setText(method.getElementName() + ":"); //$NON-NLS-1$
                            createEntryFields(method, typeComposite);
                        }
                    } else {
                        Label label = new Label(typeComposite, SWT.NONE);
                        label.setText(Signature.getSimpleName(Signature.toString(method.getReturnType())));
                        createEntryFields(method, typeComposite);
                    }
                }

                Composite buttonComposite = new Composite(mainComposite, SWT.NONE);
                gridLayout = new GridLayout(1, false);
                buttonComposite.setLayout(gridLayout);

                addButton = new Button(buttonComposite, SWT.PUSH);
                addButton.setText(JAXWSUIMessages.ANNOTATION_ARRAY_CELL_EDITOR_ADD_LABEL);
                addButton.addSelectionListener(new SelectionAdapter() {
                    @Override
                    public void widgetSelected(SelectionEvent event) {
                        try {
                            Set<Entry<String, Control>> entrySet = controls.entrySet();
                            Iterator<Map.Entry<String, Control>> iterator = entrySet.iterator();
                            List<Map<String, Object>> aList = new ArrayList<Map<String,Object>>();
                            while (iterator.hasNext()) {
                                Map.Entry<String, Control> entry = iterator.next();
                                if (entry.getValue() instanceof Text) {
                                    Text textField = (Text) entry.getValue();
                                    IMethod methodAA = (IMethod) textField.getData();
                                    if (textField.getText().trim().length() > 0) {
                                        if (componentType != null && componentType.isAnnotation())  {
                                            Map<String, Object> memberValuePairs = new HashMap<String, Object>();
                                            memberValuePairs.put(methodAA.getElementName(), textField.getText());
                                            aList.add(memberValuePairs);
                                        } else {
                                            updatedValues.add(textField.getText());
                                        }
                                    }
                                }
                                if (entry.getValue() instanceof Button) {
                                    Button button = (Button) entry.getValue();
                                    IMethod methodVV = (IMethod) button.getData();
                                    if (componentType != null && componentType.isAnnotation()) {
                                        Map<String, Object> memberValuePairs = new HashMap<String, Object>();
                                        memberValuePairs.put(methodVV.getElementName(), button.getSelection());
                                        aList.add(memberValuePairs);
                                    } else {
                                        updatedValues.add(button.getSelection());
                                    }
                                }
                            }
                            if (aList.size() > 0) {
                                updatedValues.add(aList);
                            Button button = (Button) entry.getValue();
                            Method method = (Method) button.getData();
                            if (componentType.isAnnotation()) {
                                Map<String, Object> memberValuePairs = new HashMap<String, Object>();
                                memberValuePairs.put(method.getName(), button.getSelection());
                                aList.add(memberValuePairs);
                            } else {
                                updatedValues.add(button.getSelection());
                            }
                            arrayValuesTableViewer.refresh();
                        } catch (JavaModelException jme) {
                            JAXWSUIPlugin.log(jme.getStatus());
                        }
                    }
                });
                gridData = new GridData(SWT.FILL, SWT.FILL, true, false);
                addButton.setLayoutData(gridData);

                removeButton = new Button(buttonComposite, SWT.PUSH);
                removeButton.setText(JAXWSUIMessages.ANNOTATION_ARRAY_CELL_EDITOR_REMOVE_LABEL);
                removeButton.addSelectionListener(new SelectionAdapter() {
                    @Override
                    public void widgetSelected(SelectionEvent event) {
                        ISelection selection = arrayValuesTableViewer.getSelection();
                        if (selection != null && !selection.isEmpty()) {
                            int index = arrayValuesTable.getSelectionIndex();
                            updatedValues.remove(index);
                            arrayValuesTableViewer.refresh();
                        }
                    }
                });
                gridData = new GridData(SWT.FILL, SWT.FILL, true, false);
                removeButton.setLayoutData(gridData);

                upButton = new Button(buttonComposite, SWT.PUSH);
                upButton.setText(JAXWSUIMessages.ANNOTATION_ARRAY_CELL_EDITOR_UP_LABEL);
                upButton.addSelectionListener(new SelectionAdapter() {
                    @Override
                    public void widgetSelected(SelectionEvent e) {
                        moveSelectedElememtUp(getSelectedElement(), getTableViewer());
                    }
                });

                gridData = new GridData(SWT.FILL, SWT.FILL, true, false);
                upButton.setLayoutData(gridData);

                downButton = new Button(buttonComposite, SWT.PUSH);
                downButton.setText(JAXWSUIMessages.ANNOTATION_ARRAY_CELL_EDITOR_DOWN_LABEL);
                downButton.addSelectionListener(new SelectionAdapter() {
                    @Override
                    public void widgetSelected(SelectionEvent e) {
                        moveSelectedElememtDown(getSelectedElement(), getTableViewer());
                    ISelection selection = arrayValuesTableViewer.getSelection();
                    if (selection != null && !selection.isEmpty()) {
                        int index = arrayValuesTable.getSelectionIndex();
                        updatedValues.remove(index);
                        arrayValuesTableViewer.refresh();
                    }
                });
                gridData = new GridData(SWT.FILL, SWT.FILL, true, false);
                downButton.setLayoutData(gridData);
            removeButton.setLayoutData(gridData);

            upButton = new Button(buttonComposite, SWT.PUSH);
            upButton.setText(JAXWSUIMessages.ANNOTATION_ARRAY_CELL_EDITOR_UP_LABEL);
            upButton.addSelectionListener(new SelectionAdapter() {
                @Override
                public void widgetSelected(SelectionEvent e) {
                    moveSelectedElememtUp(getSelectedElement(), getTableViewer());
                }
            });

                Composite valuesComposite = new Composite(mainComposite, SWT.NONE);
                gridLayout = new GridLayout(1, false);
                valuesComposite.setLayout(gridLayout);
                gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
                gridData.widthHint = 200;
                valuesComposite.setLayoutData(gridData);

                Label valuesLabel = new Label(valuesComposite, SWT.NONE);
                valuesLabel.setText(method.getElementName() + ":"); //$NON-NLS-1$

                arrayValuesTableViewer = new TableViewer(valuesComposite, SWT.BORDER | SWT.SINGLE | SWT.V_SCROLL | SWT.H_SCROLL);
                arrayValuesTableViewer.setLabelProvider(new LabelProvider() {
                    @Override
                    public String getText(Object element) {
                        if (element instanceof List<?>) {
                            String annotationName = componentType.getElementName();
                            annotationName += "("; //$NON-NLS-1$
                            @SuppressWarnings("unchecked")
                            List<Map<String, Object>> valuesList = (List<Map<String, Object>>) element;
                            Iterator<Map<String, Object>> valuesIterator = valuesList.iterator();
                            while (valuesIterator.hasNext()) {
                                Map<String, Object> valuesMap = valuesIterator.next();
                                Set<Entry<String, Object>> entrySet = valuesMap.entrySet();
                                Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();
                                while (iterator.hasNext()) {
                                    Map.Entry<String, Object> entry = iterator.next();
                                    Object value = entry.getValue();
                                    boolean isString = value instanceof String && !value.toString().endsWith(".class"); //$NON-NLS-1$
                                    if (isString) {
                                        annotationName += entry.getKey() + "=\"" + value + "\""; //$NON-NLS-1$ //$NON-NLS-2$
                                    } else {
                                        annotationName += entry.getKey() + "=" + value; //$NON-NLS-1$
                                    }
                                }
                                if (valuesIterator.hasNext()) {
                                    annotationName += ", "; //$NON-NLS-1$
                        List<Map<String, Object>> valuesList = (List<Map<String, Object>>)element;
                        Iterator<Map<String, Object>> valuesIterator = valuesList.iterator();
                        while (valuesIterator.hasNext()) {
                            Map<String, Object> valuesMap = valuesIterator.next();
                            Set<Entry<String, Object>> entrySet = valuesMap.entrySet();
                            Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();
                            while (iterator.hasNext()) {
                                Map.Entry<String, Object> entry = iterator.next();
                                Object value = entry.getValue();
                                boolean isString = value instanceof String && !value.toString().
                                endsWith(".class"); //$NON-NLS-1$
                                if (isString) {
                                    annotationName += entry.getKey() + "=\"" + value + "\""; //$NON-NLS-1$ //$NON-NLS-2$
                                } else {
                                    annotationName += entry.getKey() + "=" + value; //$NON-NLS-1$
                                }
                            }
                            return annotationName += ")"; //$NON-NLS-1$
                                annotationName += ", "; //$NON-NLS-1$
                            }
                        }
                        return element.toString();
                    }
                    return element.toString();
                }

                    @Override
                    public Image getImage(Object element) {
                        try {
                            if (componentType != null && componentType.isAnnotation()) {
                                return JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_ANNOTATION);
                            } else if (SignatureUtils.isClass(method.getReturnType())) {
                                return JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_CLASS);
                            } else {
                                return PlatformUI.getWorkbench().getSharedImages().getImage(
                                        org.eclipse.ui.ISharedImages.IMG_OBJ_FILE);
                            }
                        } catch (JavaModelException jme) {
                            JAXWSUIPlugin.log(jme.getStatus());
                        }
                        return null;
                    }
                });
            });

                arrayValuesTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
                    public void selectionChanged(SelectionChangedEvent event) {
                        int index = arrayValuesTable.getSelectionIndex();
                        int itemCount = arrayValuesTable.getItemCount();

                        if (index == 0 && itemCount <= 1) {
                            upButton.setEnabled(false);
                            downButton.setEnabled(false);
                        }

                        if (index == 0 && itemCount > 1) {
                            upButton.setEnabled(false);
                            downButton.setEnabled(true);
                        }

                        if (index > 0 && index < itemCount - 1) {
                            upButton.setEnabled(true);
                            downButton.setEnabled(true);
                        }

                        if (index > 0 && index == itemCount - 1) {
                            upButton.setEnabled(true);
                            downButton.setEnabled(false);
                        }

                        if (index != -1) {
                            removeButton.setEnabled(true);
                        } else {
                            removeButton.setEnabled(false);
                        }
                    }
                });
            });

                arrayValuesTableViewer.setContentProvider(new ArrayValuesContentProvider());

                arrayValuesTable = arrayValuesTableViewer.getTable();
                gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
                arrayValuesTable.setLayoutData(gridData);

                arrayValuesTableViewer.setInput(values);

                upButton.setEnabled(false);
                downButton.setEnabled(false);
                removeButton.setEnabled(false);
            } catch (JavaModelException jme) {
                jme.printStackTrace();
            }

            return mainComposite;
        }

        private IType getComponentType(IMethod method) throws JavaModelException {
            String returnType = method.getReturnType();
            if (SignatureUtils.isArray(returnType)) {
                String elementType = Signature.getElementType(returnType);
                IType declaringType = method.getDeclaringType();
                IJavaProject javaProject = declaringType.getJavaProject();
                if (javaProject != null) {
                    return javaProject.findType(Signature.toString(elementType));
                }
            }
            return null;
        }

        private void createEntryFields(IMethod method, Composite typeComposite) throws JavaModelException {
            //TODO Handle ENUMS
            String returnType = method.getReturnType();
            IMemberValuePair defaultValue = method.getDefaultValue();
            GridData gridData = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
            //String or String[]
            if (SignatureUtils.isString(returnType) || SignatureUtils.isArray(returnType) && SignatureUtils.isString(Signature.getElementType(returnType))) {
                Text text = new Text(typeComposite, SWT.BORDER);
                text.setData(method);
                gridData.horizontalSpan = 2;
                text.setLayoutData(gridData);
                if (defaultValue != null) {
                    Object value = defaultValue.getValue();
                    if (value instanceof Object[]) {
                        Object[] values = (Object[]) value;
                        if (values.length == 1) {
                            text.setText(values[0].toString());
                        }
                    } else if (value instanceof String[]) {
                        String[] values = (String[]) value;
                        if (values.length == 1) {
                            text.setText(values[0]);
                        }
                    } else {
                        text.setText(value.toString());
                    }
                }
                controls.put(method.getElementName(), text);
            }
            //Class or Class[]
            if (SignatureUtils.isClass(returnType) || SignatureUtils.isArray(returnType) && SignatureUtils.isClass(Signature.getElementType(returnType))) {
                final Text text = new Text(typeComposite, SWT.BORDER);
                text.setData(method);
                gridData = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
                text.setLayoutData(gridData);
                if (defaultValue != null && defaultValue.getValueKind() == IMemberValuePair.K_CLASS) {
                    Object value = defaultValue.getValue();
                    text.setText(value + ".class"); //$NON-NLS-1$
                }
                Button browseClassButton = new Button(typeComposite, SWT.PUSH);
                browseClassButton.setText(getBrowseButtonLabel());

                    }
                });
                browse_button_count++;
                controls.put(method.getElementName(), text);
            }

            //Boolean
            if (SignatureUtils.isBoolean(returnType)) {
                Button checkbox = new Button(typeComposite, SWT.CHECK);
                checkbox.setData(method);
                gridData.horizontalSpan = 2;
                checkbox.setLayoutData(gridData);
                if (defaultValue != null) {
                    checkbox.setSelection((Boolean) defaultValue.getValue());
                }
                controls.put(method.getElementName(), checkbox);
            }
        }


            }
        }

        private Object getSelectedElement() {
            IStructuredSelection selection= (IStructuredSelection) arrayValuesTableViewer.getSelection();
            return selection.getFirstElement();
        }

            return arrayValuesTableViewer;
        }

        private void moveSelectedElememtUp(Object selected, TableViewer tableViewer) {
            int selectionIndex = tableViewer.getTable().getSelectionIndex();
            if (selectionIndex > 0) {
                updatedValues.remove(selected);

            }
        }

        private void moveSelectedElememtDown(Object selected, TableViewer tableViewer) {
            int selectionIndex = tableViewer.getTable().getSelectionIndex();
            int itemCount = tableViewer.getTable().getItemCount();
            if (selectionIndex < itemCount - 1) {

            }
        }

        private SelectionDialog getClassSelectionDialog() {
            try {
                return JavaUI.createTypeDialog(getShell(), PlatformUI.getWorkbench().getProgressService(),
                        SearchEngine.createWorkspaceScope(), IJavaElementSearchConstants.CONSIDER_CLASSES,




 *******************************************************************************/
package org.eclipse.jst.ws.internal.jaxws.ui.views;

import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.ui.ISharedImages;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.viewers.ColumnLabelProvider;


    @Override
    public String getText(Object element) {
        if (element instanceof IType) {
            return ((IType) element).getFullyQualifiedName();
        }
        
        if (element instanceof IMethod) {
            return ((IMethod) element).getElementName();
        }
        return ""; //$NON-NLS-1$
    }

    @Override
    public Image getImage(Object element) {
        if (element instanceof IType) {
            return JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_ANNOTATION);
        }
        if (element instanceof IMethod) {
            return PlatformUI.getWorkbench().getSharedImages().getImage(
                    org.eclipse.ui.ISharedImages.IMG_OBJ_FILE);
        }




 *******************************************************************************/
package org.eclipse.jst.ws.internal.jaxws.ui.views;

import java.lang.reflect.Method;
import java.util.List;

import org.eclipse.jdt.core.IJavaElement;
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.jdt.core.dom.Annotation;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.BooleanLiteral;

import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jst.ws.annotations.core.utils.AnnotationUtils;
import org.eclipse.jst.ws.internal.annotations.core.utils.SignatureUtils;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;
import org.eclipse.swt.graphics.Image;



    @Override
    public String getText(Object element) {
        if (element instanceof IMethod) {
            try {
                return getTextForMethod((IMethod) element);
            } catch (JavaModelException jme) {
                JAXWSUIPlugin.log(jme.getStatus());
            }
        }
        return ""; //$NON-NLS-1$
    }

    private String getTextForMethod(IMethod method) throws JavaModelException {
        if (annotationTreeViewer.getInput() instanceof IJavaElement) {
            IJavaElement javaElement = (IJavaElement) annotationTreeViewer.getInput();
            if (javaElement.exists()) {

        return ""; //$NON-NLS-1$
    }

    private String getTextForMethod(IMethod method, IJavaElement annotatedElement) throws JavaModelException {
        List<Annotation> annotations = AnnotationUtils.getAnnotations(annotatedElement);
        for (Annotation annotation : annotations) {
            String annotationName = AnnotationUtils.getAnnotationName(annotation);
            IType type = method.getDeclaringType();
            if (type != null && annotationName.equals(type.getElementName())
                    || annotationName.equals(type.getFullyQualifiedName())) {
                if (annotation.isNormalAnnotation()) {
                    NormalAnnotation normalAnnotation = (NormalAnnotation) annotation;
                    @SuppressWarnings("unchecked")
                    List<MemberValuePair> memberValuePairs = normalAnnotation.values();
                    for (MemberValuePair memberValuePair : memberValuePairs) {
                        if (memberValuePair.getName().getIdentifier().equals(method.getElementName())) {
                            return getTextForMethod(method, memberValuePair.getValue());
                        }
                    }
                } else if (annotation.isSingleMemberAnnotation()) {
                    SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) annotation;
                    return getTextForMethod(method, singleMemberAnnotation.getValue());
                }
            }
        }
        return ""; //$NON-NLS-1$
    }

    private String getTextForMethod(IMethod method, Expression expression) throws JavaModelException {
        String returnType = method.getReturnType();

        if (SignatureUtils.isString(returnType) || SignatureUtils.isClass(returnType)) {
            return expression.toString();
        }

        if (SignatureUtils.isEnum(method)) {
            String enumValue = expression.toString();
            return enumValue.substring(enumValue.lastIndexOf(".") + 1); //$NON-NLS-1$
        }

        if (SignatureUtils.isPrimitive(returnType) && (returnType.charAt(0) == Signature.C_BYTE
                || returnType.charAt(0) == Signature.C_SHORT || returnType.charAt(0) == Signature.C_INT
                || returnType.charAt(0) == Signature.C_LONG  || returnType.charAt(0) == Signature.C_FLOAT
                || returnType.charAt(0) == Signature.C_DOUBLE)) {
            return expression.toString();
        }

        if (SignatureUtils.isArray(returnType) && expression instanceof ArrayInitializer) {
            ArrayInitializer arrayInitializer = (ArrayInitializer) expression;
            if (arrayInitializer.expressions().size() > 0) {
                return "[]{...}"; //$NON-NLS-1$

                return "[]{}"; //$NON-NLS-1$
            }
        }
        if (returnType.isEnum()) {
            String enumValue = expression.toString();
            return enumValue.substring(enumValue.lastIndexOf(".") + 1); //$NON-NLS-1$
        }
        return ""; //$NON-NLS-1$
    }

    @Override
    public Image getImage(Object element) {
        try {
            if (element instanceof IType) {
                return getImageForClass((IType) element);
            }
            if (element instanceof IMethod) {
                return getImageForMethod((IMethod) element);
            }
        } catch (JavaModelException jme) {
            JAXWSUIPlugin.log(jme.getStatus());

        return null;
    }

    private Image getImageForClass(IType type) throws JavaModelException {
        if (annotationTreeViewer.getInput() instanceof IJavaElement) {
            IJavaElement javaElement = (IJavaElement) annotationTreeViewer.getInput();
            if (javaElement.exists()) {
                return getImageForClass(type, javaElement);
            }
        }
        return null;
    }

    private Image getImageForClass(IType type, IJavaElement javaElement) throws JavaModelException {
        List<Annotation> annotations = AnnotationUtils.getAnnotations(javaElement);
        for (Annotation annotation : annotations) {
            String annotationName = AnnotationUtils.getAnnotationName(annotation);
            if (annotationName.equals(type.getElementName()) ||
                    annotationName.equals(type.getFullyQualifiedName())) {
                return true_image;
            }
        }
        return false_image;
    }

    private Image getImageForMethod(IMethod method) throws JavaModelException {
        if (SignatureUtils.isBoolean(method.getReturnType()) && annotationTreeViewer.getInput() instanceof IJavaElement) {
            IJavaElement javaElement = (IJavaElement) annotationTreeViewer.getInput();
            if (javaElement.exists()) {
                return getImageForMethod(method, javaElement);

        return null;
    }

    private Image getImageForMethod(IMethod method, IJavaElement javaElement) throws JavaModelException {
        List<Annotation> annotations = AnnotationUtils.getAnnotations(javaElement);
        for (Annotation annotation : annotations) {
            String annotationName = AnnotationUtils.getAnnotationName(annotation);
            IType declaringType = method.getDeclaringType();
            if (declaringType != null && annotationName.equals(declaringType.getElementName())
                    || annotationName.equals(declaringType.getFullyQualifiedName())) {
                if (annotation.isNormalAnnotation()) {
                    NormalAnnotation normalAnnotation = (NormalAnnotation) annotation;
                    @SuppressWarnings("unchecked")
                    List<MemberValuePair> memberValuePairs = normalAnnotation.values();
                    for (MemberValuePair memberValuePair : memberValuePairs) {
                        if (memberValuePair.getName().getIdentifier().equals(method.getElementName())
                                && memberValuePair.getValue() instanceof BooleanLiteral) {
                            if (((BooleanLiteral) memberValuePair.getValue()).booleanValue()) {
                                return true_image;

Lines 10-16 Link Here

(-)src/org/eclipse/jst/ws/internal/jaxws/ui/views/AnnotationsValuesEditingSupport.java (-226 / +315 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jst.ws.internal.jaxws.ui.views;	11	package org.eclipse.jst.ws.internal.jaxws.ui.views;
12		12
13	import java.lang.reflect.Method;
14	import java.util.ArrayList;	13	import java.util.ArrayList;
15	import java.util.Collections;	14	import java.util.Collections;
16	import java.util.Iterator;	15	import java.util.Iterator;
Lines 27-34 Link Here
27	import org.eclipse.jdt.core.IAnnotation;	26	import org.eclipse.jdt.core.IAnnotation;
28	import org.eclipse.jdt.core.ICompilationUnit;	27	import org.eclipse.jdt.core.ICompilationUnit;
29	import org.eclipse.jdt.core.IJavaElement;	28	import org.eclipse.jdt.core.IJavaElement;
		29	import org.eclipse.jdt.core.IJavaProject;
		30	import org.eclipse.jdt.core.ILocalVariable;
30	import org.eclipse.jdt.core.IMemberValuePair;	31	import org.eclipse.jdt.core.IMemberValuePair;
		32	import org.eclipse.jdt.core.IMethod;
		33	import org.eclipse.jdt.core.IType;
31	import org.eclipse.jdt.core.JavaModelException;	34	import org.eclipse.jdt.core.JavaModelException;
		35	import org.eclipse.jdt.core.Signature;
32	import org.eclipse.jdt.core.dom.AST;	36	import org.eclipse.jdt.core.dom.AST;
33	import org.eclipse.jdt.core.dom.ASTNode;	37	import org.eclipse.jdt.core.dom.ASTNode;
34	import org.eclipse.jdt.core.dom.Annotation;	38	import org.eclipse.jdt.core.dom.Annotation;
Lines 51-56 Link Here
51	import org.eclipse.jst.ws.annotations.core.AnnotationsManager;	55	import org.eclipse.jst.ws.annotations.core.AnnotationsManager;
52	import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;	56	import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;
53	import org.eclipse.jst.ws.annotations.core.utils.AnnotationUtils;	57	import org.eclipse.jst.ws.annotations.core.utils.AnnotationUtils;
		58	import org.eclipse.jst.ws.internal.annotations.core.utils.SignatureUtils;
54	import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIMessages;	59	import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIMessages;
55	import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;	60	import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;
56	import org.eclipse.ltk.core.refactoring.Change;	61	import org.eclipse.ltk.core.refactoring.Change;
Lines 61-66 Link Here
61	import org.eclipse.text.edits.MultiTextEdit;	66	import org.eclipse.text.edits.MultiTextEdit;
62		67
63	public class AnnotationsValuesEditingSupport extends EditingSupport {	68	public class AnnotationsValuesEditingSupport extends EditingSupport {
		69
64	private AnnotationsView annotationsView;	70	private AnnotationsView annotationsView;
65	private TreeViewer treeViewer;	71	private TreeViewer treeViewer;
66		72
Lines 83-186 Link Here
83		89
84	@Override	90	@Override
85	protected boolean canEdit(Object element) {	91	protected boolean canEdit(Object element) {
86	if (element instanceof Method) {	92	if (element instanceof IMethod) {
87	Method method = (Method)element;	93	IMethod method = (IMethod) element;
88	return (Boolean) getValue(method.getDeclaringClass());	94	return (Boolean) getValue(method.getDeclaringType());
89	}	95	}
90	return true;	96	return true;
91	}	97	}
92		98
93	@Override	99	@Override
94	protected CellEditor getCellEditor(Object element) {	100	protected CellEditor getCellEditor(Object element) {
95	if (element instanceof Class) {	101	if (element instanceof IType) {
96	return checkboxCellEditor;	102	return checkboxCellEditor;
97	}	103	}
98	if (element instanceof Method) {	104	if (element instanceof IMethod) {
99	Method method = (Method) element;	105	try {
100	final Class<?> returnType = method.getReturnType();	106	IMethod method = (IMethod) element;
101	if (returnType.isEnum()) {	107
102	Object[] enumConstants = returnType.getEnumConstants();	108	IType enumType = SignatureUtils.getEnumReturnType(method);
103	String[] values = new String[enumConstants.length];	109	if (enumType != null) {
104	for (int i = 0; i < enumConstants.length; i++) {	110	comboBoxCellEditor.setItems(SignatureUtils.getEnumConstantsNames(enumType));
105	values[i] = enumConstants[i].toString();	111	return comboBoxCellEditor;
106	}	112	}
107	comboBoxCellEditor.setItems(values);	113
108	return comboBoxCellEditor;	114	final String returnType = method.getReturnType();
109	}	115
110	if (returnType.equals(Boolean.TYPE)) {	116	if (SignatureUtils.isBoolean(returnType)) {
111	return checkboxCellEditor;	117	return checkboxCellEditor;
112	}	118	}
113		119
114	if (returnType.equals(Class.class)) {	120	if (SignatureUtils.isClass(returnType)) {
115	return classDialogCellEditor;	121	return classDialogCellEditor;
116	}	122	}
117		123
118	if (returnType.isArray()) {	124	if (SignatureUtils.isArray(returnType)) {
119	annotationArrayCellEditor.setMethod(method);	125	annotationArrayCellEditor.setMethod(method);
120	return annotationArrayCellEditor;	126	return annotationArrayCellEditor;
121	}	127	}
122	if (returnType.isPrimitive()) {	128	if (SignatureUtils.isPrimitive(returnType)) {
123	textCellEditor.setValidator(new ICellEditorValidator() {	129	textCellEditor.setValidator(new ICellEditorValidator() {
124	public String isValid(Object value) {	130	public String isValid(Object value) {
125	try {	131	try {
126	if (returnType.equals(Byte.TYPE)) {	132	if (returnType.charAt(0) == Signature.C_BYTE) {
127	Byte.parseByte((String) value);	133	Byte.parseByte((String) value);
128	}	134	}
129	if (returnType.equals(Short.TYPE)) {	135	if (returnType.charAt(0) == Signature.C_SHORT) {
130	Short.parseShort((String) value);	136	Short.parseShort((String) value);
131	}	137	}
132	if (returnType.equals(Integer.TYPE)) {	138	if (returnType.charAt(0) == Signature.C_INT) {
133	Integer.parseInt((String) value);	139	Integer.parseInt((String) value);
134	}	140	}
135	if (returnType.equals(Long.TYPE)) {	141	if (returnType.charAt(0) == Signature.C_LONG) {
136	Long.parseLong((String) value);	142	Long.parseLong((String) value);
137	}	143	}
138	if (returnType.equals(Float.TYPE)) {	144	if (returnType.charAt(0) == Signature.C_FLOAT) {
139	Float.parseFloat((String) value);	145	Float.parseFloat((String) value);
140	}	146	}
141	if (returnType.equals(Double.TYPE)) {	147	if (returnType.charAt(0) == Signature.C_DOUBLE) {
142	Double.parseDouble((String) value);	148	Double.parseDouble((String) value);
		149	}
		150	} catch (NumberFormatException nfe) {
		151	return JAXWSUIMessages.ANNOTATION_EDITING_SUPPORT_NOT_VALID_MESSAGE_PREFIX + value;
143	}	152	}
144	} catch (NumberFormatException nfe) {	153	return null;
145	return JAXWSUIMessages.ANNOTATION_EDITING_SUPPORT_NOT_VALID_MESSAGE_PREFIX
146	+ returnType.getSimpleName();
147	}	154	}
148	return null;	155	});
149	}	156	return textCellEditor;
150	});	157	}
151	return textCellEditor;	158	return textCellEditor;
		159	} catch (JavaModelException jme) {
		160	JAXWSUIPlugin.log(jme.getStatus());
152	}	161	}
153	return textCellEditor;
154	}	162	}
155	return checkboxCellEditor;	163	return checkboxCellEditor;
156	}	164	}
157		165
158	@Override	166	@Override
159	protected Object getValue(Object element) {	167	protected Object getValue(Object element) {
160	if (element instanceof Class) {	168	if (element instanceof IType) {
161	return getValueForClass((Class<?>) element);	169	return getValueForClass((IType) element);
162	}	170	}
163	if (element instanceof Method) {	171	if (element instanceof IMethod) {
164	return getValueForMethod((Method) element);	172	return getValueForMethod((IMethod) element);
165	}	173	}
166	return null;	174	return null;
167	}	175	}
168		176
169	private Object getValueForClass(Class<?> aClass) {	177	private Object getValueForClass(IType type) {
170	if (treeViewer.getInput() instanceof IAnnotatable) {	178	if (treeViewer.getInput() instanceof IAnnotatable) {
171	return getValueForClass(aClass, (IAnnotatable) treeViewer.getInput());	179	return getValueForClass(type, (IAnnotatable) treeViewer.getInput());
172	}	180	}
173	return Boolean.FALSE;	181	return Boolean.FALSE;
174	}	182	}
175		183
176	private Object getValueForClass(Class<?> aClass, IAnnotatable annotatedElement) {	184	private Object getValueForClass(IType type, IAnnotatable annotatedElement) {
		185	if (annotatedElement instanceof ILocalVariable) {
		186	ILocalVariable localVariable = getLocalVariable(annotatedElement);
		187	if (localVariable != null) {
		188	annotatedElement = localVariable;
		189	}
		190	}
177	try {	191	try {
178	IAnnotation[] annotations = annotatedElement.getAnnotations();	192	IAnnotation[] annotations = annotatedElement.getAnnotations();
179	for (IAnnotation annotation : annotations) {	193	for (IAnnotation annotation : annotations) {
180	String annotationName = annotation.getElementName();	194	String annotationName = annotation.getElementName();
181	if (AnnotationUtils.isAnnotationPresent((IJavaElement)annotatedElement, annotationName)	195	if (AnnotationUtils.isAnnotationPresent((IJavaElement)annotatedElement, annotationName)
182	&& (annotationName.equals(aClass.getSimpleName())	196	&& (annotationName.equals(type.getElementName())
183	\|\| annotationName.equals(aClass.getCanonicalName()))) {	197	\|\| annotationName.equals(type.getFullyQualifiedName()))) {
184	return Boolean.TRUE;	198	return Boolean.TRUE;
185	}	199	}
186	}	200	}
Lines 190-196 Link Here
190	return Boolean.FALSE;	204	return Boolean.FALSE;
191	}	205	}
192		206
193	private Object getValueForMethod(Method method) {	207	private Object getValueForMethod(IMethod method) {
194	Object value = null;	208	Object value = null;
195	try {	209	try {
196	if (treeViewer.getInput() instanceof IAnnotatable) {	210	if (treeViewer.getInput() instanceof IAnnotatable) {
Lines 202-245 Link Here
202	return value;	216	return value;
203	}	217	}
204		218
205	private Object getValueForMethod(Method method, IAnnotatable annotatedElement) throws JavaModelException {	219	private ILocalVariable getLocalVariable(IAnnotatable annotatedElement) {
206	Class<?> returnType = method.getReturnType();	220	if (annotatedElement instanceof ILocalVariable) {
		221	ILocalVariable localVariable = (ILocalVariable) annotatedElement;
		222	if (localVariable.getParent() instanceof IMethod) {
		223	IMethod parent = (IMethod) localVariable.getParent();
		224	localVariable = AnnotationUtils.getLocalVariable(parent, localVariable.getElementName());
		225	if (localVariable != null) {
		226	return localVariable;
		227	}
		228	}
		229	}
		230	return null;
		231	}
		232
		233	private Object getValueForMethod(IMethod method, IAnnotatable annotatedElement) throws JavaModelException {
		234	String returnType = method.getReturnType();
		235	if (annotatedElement instanceof ILocalVariable) {
		236	ILocalVariable localVariable = getLocalVariable(annotatedElement);
		237	if (localVariable != null) {
		238	annotatedElement = localVariable;
		239	}
		240	}
207	IAnnotation[] annotations = annotatedElement.getAnnotations();	241	IAnnotation[] annotations = annotatedElement.getAnnotations();
208	for (IAnnotation annotation : annotations) {	242	for (IAnnotation annotation : annotations) {
209	Class<?> declaringClass = method.getDeclaringClass();	243	IType declaringType = method.getDeclaringType();
		244
210	String annotationName = annotation.getElementName();	245	String annotationName = annotation.getElementName();
211	if (annotationName.equals(declaringClass.getSimpleName())	246	if (annotationName.equals(declaringType.getElementName())
212	\|\| annotationName.equals(declaringClass.getCanonicalName())) {	247	\|\| annotationName.equals(declaringType.getFullyQualifiedName())) {
213	IMemberValuePair[] memberValuePairs = annotation.getMemberValuePairs();	248	IMemberValuePair[] memberValuePairs = annotation.getMemberValuePairs();
214	for (IMemberValuePair memberValuePair : memberValuePairs) {	249	for (IMemberValuePair memberValuePair : memberValuePairs) {
215	if (memberValuePair.getMemberName().equals(method.getName())) {	250	if (memberValuePair.getMemberName().equals(method.getElementName())) {
216	if (returnType.equals(String.class)) {	251	if (SignatureUtils.isString(returnType)) {
217	return memberValuePair.getValue();	252	return memberValuePair.getValue();
218	}	253	}
219		254
220	if (returnType.isEnum()) {	255	IType enumType = SignatureUtils.getEnumReturnType(method);
		256	if (enumType != null) {
221	String enumValue = memberValuePair.getValue().toString();	257	String enumValue = memberValuePair.getValue().toString();
222	String literal = enumValue.substring(enumValue.lastIndexOf(".") + 1); //$NON-NLS-1$	258	String literal = enumValue.substring(enumValue.lastIndexOf(".") + 1); //$NON-NLS-1$
223	Object[] enumConstants = method.getReturnType().getEnumConstants();	259	String[] enumConstants = SignatureUtils.getEnumConstantsNames(enumType);
224	for (int i = 0; i < enumConstants.length; i++) {	260	for (int i = 0; i < enumConstants.length; i++) {
225	if (enumConstants[i].toString().equals(literal)) {	261	if (enumConstants[i].equals(literal)) {
226	return i;	262	return i;
227	}	263	}
228	}	264	}
229	}	265	}
230		266	if (SignatureUtils.isClass(returnType)) {
231	if (returnType.equals(Class.class)) {
232	return memberValuePair.getValue();	267	return memberValuePair.getValue();
233	}	268	}
234		269
235	if (returnType.equals(Boolean.TYPE)) {	270	if (SignatureUtils.isBoolean(returnType)) {
236	return memberValuePair.getValue();	271	return memberValuePair.getValue();
237	}	272	}
238		273
239	if (returnType.isPrimitive()) {	274	if (SignatureUtils.isPrimitive(returnType)) {
240	return ""; //$NON-NLS-1$	275	return ""; //$NON-NLS-1$
241	}	276	}
242	if (returnType.isArray()) {	277	if (SignatureUtils.isArray(returnType)) {
243	if (memberValuePair.getValueKind() == IMemberValuePair.K_CLASS) {	278	if (memberValuePair.getValueKind() == IMemberValuePair.K_CLASS) {
244	Object[] arrayValues = (Object[])memberValuePair.getValue();	279	Object[] arrayValues = (Object[])memberValuePair.getValue();
245	for (int i = 0; i < arrayValues.length; i++) {	280	for (int i = 0; i < arrayValues.length; i++) {
Lines 252-279 Link Here
252	}	287	}
253	}	288	}
254	}	289	}
255	return getDefaultValueForMethod(returnType);	290	return getDefaultValueForMethod(method);
256	}	291	}
257	}	292	}
258	return null;	293	return null;
259	}	294	}
260		295
261	private Object getDefaultValueForMethod(Class<?> returnType) {	296	private Object getDefaultValueForMethod(IMethod method) throws JavaModelException {
262	if (returnType.equals(String.class)) {	297	String returnType = method.getReturnType();
		298
		299	if (SignatureUtils.isString(returnType)) {
263	return ""; //$NON-NLS-1$	300	return ""; //$NON-NLS-1$
264	}	301	}
265	if (returnType.equals(Boolean.TYPE)) {	302
		303	if (SignatureUtils.isBoolean(returnType)) {
266	return Boolean.FALSE;	304	return Boolean.FALSE;
267	}	305	}
268	if (returnType.isEnum()) {	306
		307	if (SignatureUtils.isEnum(method)) {
269	return -1;	308	return -1;
270	}	309	}
271	if (returnType.isPrimitive()) {	310
		311	if (SignatureUtils.isPrimitive(returnType)) {
272	return ""; //$NON-NLS-1$	312	return ""; //$NON-NLS-1$
273	}	313	}
274	if (returnType.isArray()) {	314
		315	if (SignatureUtils.isArray(returnType)) {
275	return new Object[] {};	316	return new Object[] {};
276	}	317	}
		318
277	return null;	319	return null;
278	}	320	}
279		321
Lines 284-324 Link Here
284	}	326	}
285		327
286	try {	328	try {
287	if (element instanceof Class && ((Class<?>) element).isAnnotation()) {	329	if (element instanceof IType && ((IType) element).isAnnotation()) {
288	@SuppressWarnings("unchecked")	330	setValueForClass((IType) element, (Boolean) value);
289	Class<? extends java.lang.annotation.Annotation> annotationClass =
290	(Class<? extends java.lang.annotation.Annotation>) element;
291	if (annotationClass != null) {
292	setValueForClass(annotationClass, (Boolean) value);
293	}
294	}	331	}
295	if (element instanceof Method) {	332
296	setValueForMethod((Method) element, value);	333	if (element instanceof IMethod) {
		334	setValueForMethod((IMethod) element, value);
297	}	335	}
298	} catch (CoreException ce) {	336	} catch (CoreException ce) {
299	JAXWSUIPlugin.log(ce.getStatus());	337	JAXWSUIPlugin.log(ce.getStatus());
300	}	338	}
301	}	339	}
302		340
303	private void setValueForClass(Class<? extends java.lang.annotation.Annotation> annotationClass,	341	private void setValueForClass(IType type, Boolean annotate) throws CoreException {
304	Boolean annotate) throws CoreException {
305	Object viewerInput = treeViewer.getInput();	342	Object viewerInput = treeViewer.getInput();
306		343
307	IAnnotationAttributeInitializer annotationAttributeInitializer =	344	IAnnotationAttributeInitializer annotationAttributeInitializer =
308	AnnotationsManager.getAnnotationDefinitionForClass(annotationClass).getAnnotationAttributeInitializer();	345	AnnotationsManager.getAnnotationDefinitionForClass(type.getFullyQualifiedName()).getAnnotationAttributeInitializer();
309		346
310	if (viewerInput instanceof IJavaElement) {	347	if (viewerInput instanceof IJavaElement) {
311	setValueForClass(annotationClass, annotate, (IJavaElement) viewerInput, annotationAttributeInitializer);	348	setValueForClass(type, annotate, (IJavaElement) viewerInput, annotationAttributeInitializer);
312	}	349	}
313	}	350	}
314		351
315	private Annotation getAnnotation(AST ast, Class<? extends java.lang.annotation.Annotation> annotationClass,	352	private Annotation getAnnotation(AST ast, IType type, List<MemberValuePair> memberValuePairs) throws JavaModelException {
316	List<MemberValuePair> memberValuePairs) {
317
318	Annotation annotation = null;	353	Annotation annotation = null;
319	int numberOfDeclaredMethods = annotationClass.getDeclaredMethods().length;	354	int numberOfDeclaredMethods = type.getMethods().length;
320	if (numberOfDeclaredMethods == 0) {	355	if (numberOfDeclaredMethods == 0) {
321	annotation = AnnotationsCore.createMarkerAnnotation(ast, annotationClass.getSimpleName());	356	annotation = AnnotationsCore.createMarkerAnnotation(ast, type.getElementName());
322	} else if (numberOfDeclaredMethods == 1) {	357	} else if (numberOfDeclaredMethods == 1) {
323	Expression value = null;	358	Expression value = null;
324	if (memberValuePairs != null && memberValuePairs.size() == 1) {	359	if (memberValuePairs != null && memberValuePairs.size() == 1) {
Lines 328-355 Link Here
328	}	363	}
329	}	364	}
330	if (value != null) {	365	if (value != null) {
331	annotation = AnnotationsCore.createSingleMemberAnnotation(ast, annotationClass.getSimpleName(), value);	366	annotation = AnnotationsCore.createSingleMemberAnnotation(ast, type.getElementName(), value);
332	} else {	367	} else {
333	annotation = AnnotationsCore.createNormalAnnotation(ast, annotationClass.getSimpleName(), memberValuePairs);	368	annotation = AnnotationsCore.createNormalAnnotation(ast, type.getElementName(), memberValuePairs);
334	}	369	}
335	} else if (numberOfDeclaredMethods > 1) {	370	} else if (numberOfDeclaredMethods > 1) {
336	annotation = AnnotationsCore.createNormalAnnotation(ast, annotationClass.getSimpleName(), memberValuePairs);	371	annotation = AnnotationsCore.createNormalAnnotation(ast, type.getElementName(), memberValuePairs);
337	}	372	}
338		373
339	return annotation;	374	return annotation;
340	}	375	}
341		376
342	private void setValueForClass(Class<? extends java.lang.annotation.Annotation> annotationClass,	377	private void setValueForClass(IType type, Boolean annotate, IJavaElement javaElement,
343	Boolean annotate, IJavaElement javaElement, IAnnotationAttributeInitializer annotationAttributeInitializer)	378	IAnnotationAttributeInitializer annotationAttributeInitializer) throws CoreException {
344	throws CoreException {
345	ICompilationUnit source = AnnotationUtils.getCompilationUnitFromJavaElement(javaElement);	379	ICompilationUnit source = AnnotationUtils.getCompilationUnitFromJavaElement(javaElement);
346	CompilationUnit compilationUnit = SharedASTProvider.getAST(source, SharedASTProvider.WAIT_YES, null);	380	CompilationUnit compilationUnit = SharedASTProvider.getAST(source, SharedASTProvider.WAIT_YES, null);
347	AST ast = compilationUnit.getAST();	381	AST ast = compilationUnit.getAST();
348		382
349	List<MemberValuePair> memberValuePairs = getMemberValuePairs(annotationAttributeInitializer, javaElement,	383	List<MemberValuePair> memberValuePairs = getMemberValuePairs(annotationAttributeInitializer, javaElement,
350	ast, annotationClass);	384	ast, type);
351		385
352	Annotation annotation = getAnnotation(ast, annotationClass, memberValuePairs);	386	Annotation annotation = getAnnotation(ast, type, memberValuePairs);
353		387
354	TextFileChange change = new TextFileChange("Add/Remove Annotation", (IFile) source.getResource()); //$NON-NLS-1$	388	TextFileChange change = new TextFileChange("Add/Remove Annotation", (IFile) source.getResource()); //$NON-NLS-1$
355	MultiTextEdit multiTextEdit = new MultiTextEdit();	389	MultiTextEdit multiTextEdit = new MultiTextEdit();
Lines 361-368 Link Here
361	\|\| javaElement.getElementType() == IJavaElement.FIELD	395	\|\| javaElement.getElementType() == IJavaElement.FIELD
362	\|\| javaElement.getElementType() == IJavaElement.METHOD	396	\|\| javaElement.getElementType() == IJavaElement.METHOD
363	\|\| javaElement.getElementType() == IJavaElement.LOCAL_VARIABLE) {	397	\|\| javaElement.getElementType() == IJavaElement.LOCAL_VARIABLE) {
		398	change.addEdit(AnnotationUtils.createAddImportTextEdit(javaElement, type.getFullyQualifiedName()));
364	change.addEdit(AnnotationUtils.createAddAnnotationTextEdit(javaElement, annotation));	399	change.addEdit(AnnotationUtils.createAddAnnotationTextEdit(javaElement, annotation));
365	change.addEdit(AnnotationUtils.createAddImportTextEdit(javaElement, annotationClass.getCanonicalName()));
366	}	400	}
367	} else {	401	} else {
368	if (javaElement.getElementType() == IJavaElement.PACKAGE_DECLARATION	402	if (javaElement.getElementType() == IJavaElement.PACKAGE_DECLARATION
Lines 371-394 Link Here
371	\|\| javaElement.getElementType() == IJavaElement.METHOD	405	\|\| javaElement.getElementType() == IJavaElement.METHOD
372	\|\| javaElement.getElementType() == IJavaElement.LOCAL_VARIABLE) {	406	\|\| javaElement.getElementType() == IJavaElement.LOCAL_VARIABLE) {
373	change.addEdit(AnnotationUtils.createRemoveAnnotationTextEdit(javaElement, annotation));	407	change.addEdit(AnnotationUtils.createRemoveAnnotationTextEdit(javaElement, annotation));
374	change.addEdit(AnnotationUtils.createRemoveImportTextEdit(javaElement, annotationClass.getCanonicalName()));	408	change.addEdit(AnnotationUtils.createRemoveImportTextEdit(javaElement, type.getFullyQualifiedName()));
375	}	409	}
376	}	410	}
377	executeChange(new NullProgressMonitor(), change);	411	executeChange(new NullProgressMonitor(), change);
378	}	412	}
379		413
380	private List<MemberValuePair> getMemberValuePairs(	414	private List<MemberValuePair> getMemberValuePairs(IAnnotationAttributeInitializer annotationAttributeInitializer,
381	IAnnotationAttributeInitializer annotationAttributeInitializer, IJavaElement javaElement, AST ast,	415	IJavaElement javaElement, AST ast, IType type) {
382	Class<?extends java.lang.annotation.Annotation> annotationClass) {
383	if (annotationAttributeInitializer != null) {	416	if (annotationAttributeInitializer != null) {
384	return annotationAttributeInitializer.getMemberValuePairs(javaElement, ast, annotationClass);	417	List<MemberValuePair> memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(javaElement, ast, type);
		418	if (memberValuePairs.size() > 0) {
		419	return memberValuePairs;
		420	} else {
		421	return annotationAttributeInitializer.getMemberValuePairs(javaElement, ast,
		422	AnnotationsManager.getAnnotationDefinitionForType(type).getAnnotationClass());
		423	}
385	}	424	}
386	return Collections.emptyList();	425	return Collections.emptyList();
387	}	426	}
388		427
389		428	private void setValueForMethod(IMethod method, Object value) throws CoreException {
390	private void setValueForMethod(Method method, Object value) throws CoreException {	429	if (value instanceof String) {
391	if (((Boolean) getValue(method.getDeclaringClass())).booleanValue()) {	430	Object currentValue = getValue(method);
		431	if (currentValue != null && currentValue instanceof String) {
		432	if (((String) value).equals(currentValue)) {
		433	return;
		434	}
		435	}
		436	}
		437	if (((Boolean) getValue(method.getDeclaringType())).booleanValue()) {
392	Object viewerInput = treeViewer.getInput();	438	Object viewerInput = treeViewer.getInput();
393	if (viewerInput instanceof IAnnotatable) {	439	if (viewerInput instanceof IAnnotatable) {
394	setValueForMethod(method, value, (IJavaElement) viewerInput);	440	setValueForMethod(method, value, (IJavaElement) viewerInput);
Lines 396-402 Link Here
396	}	442	}
397	}	443	}
398		444
399	private void setValueForMethod(Method method, Object value, IJavaElement javaElement) throws CoreException {	445	private void setValueForMethod(IMethod method, Object value, IJavaElement javaElement) throws CoreException {
400	ICompilationUnit source = AnnotationUtils.getCompilationUnitFromJavaElement(javaElement);	446	ICompilationUnit source = AnnotationUtils.getCompilationUnitFromJavaElement(javaElement);
401	CompilationUnit compilationUnit = SharedASTProvider.getAST(source, SharedASTProvider.WAIT_YES, null);	447	CompilationUnit compilationUnit = SharedASTProvider.getAST(source, SharedASTProvider.WAIT_YES, null);
402	AST ast = compilationUnit.getAST();	448	AST ast = compilationUnit.getAST();
Lines 409-422 Link Here
409	for (Annotation annotation : annotations) {	455	for (Annotation annotation : annotations) {
410	if (annotation instanceof NormalAnnotation) {	456	if (annotation instanceof NormalAnnotation) {
411	NormalAnnotation normalAnnotation = (NormalAnnotation) annotation;	457	NormalAnnotation normalAnnotation = (NormalAnnotation) annotation;
412	Class<?> declaringClass = method.getDeclaringClass();	458	IType declaringType = method.getDeclaringType();
413	String annotationName = normalAnnotation.getTypeName().getFullyQualifiedName();	459	String annotationName = normalAnnotation.getTypeName().getFullyQualifiedName();
414	if (annotationName.equals(declaringClass.getSimpleName()) \|\| annotationName.equals(declaringClass.getCanonicalName())) {	460	if (annotationName.equals(declaringType.getElementName()) \|\| annotationName.equals(declaringType.getFullyQualifiedName())) {
415	@SuppressWarnings("unchecked")	461	@SuppressWarnings("unchecked")
416	List<MemberValuePair> memberValuePairs = normalAnnotation.values();	462	List<MemberValuePair> memberValuePairs = normalAnnotation.values();
417	boolean hasMemberValuePair = false;	463	boolean hasMemberValuePair = false;
418	for (MemberValuePair memberValuePair : memberValuePairs) {	464	for (MemberValuePair memberValuePair : memberValuePairs) {
419	if (memberValuePair.getName().getIdentifier().equals(method.getName())) {	465	if (memberValuePair.getName().getIdentifier().equals(method.getElementName())) {
420	ASTNode memberValue = getMemberValuePairValue(ast, method, value);	466	ASTNode memberValue = getMemberValuePairValue(ast, method, value);
421	if (memberValue != null) {	467	if (memberValue != null) {
422	change.addEdit(AnnotationUtils.createUpdateMemberValuePairTextEdit(memberValuePair, memberValue));	468	change.addEdit(AnnotationUtils.createUpdateMemberValuePairTextEdit(memberValuePair, memberValue));
Lines 435-443 Link Here
435	}	481	}
436	} else if (annotation instanceof SingleMemberAnnotation) {	482	} else if (annotation instanceof SingleMemberAnnotation) {
437	SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) annotation;	483	SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) annotation;
438	Class<?> declaringClass = method.getDeclaringClass();	484	IType declaringType = method.getDeclaringType();
439	String annotationName = singleMemberAnnotation.getTypeName().getFullyQualifiedName();	485	String annotationName = singleMemberAnnotation.getTypeName().getFullyQualifiedName();
440	if (annotationName.equals(declaringClass.getSimpleName()) \|\| annotationName.equals(declaringClass.getCanonicalName())) {	486	if (annotationName.equals(declaringType.getElementName()) \|\| annotationName.equals(declaringType.getFullyQualifiedName())) {
441	MemberValuePair memberValuePair = getMemberValuePair(ast, method, value);	487	MemberValuePair memberValuePair = getMemberValuePair(ast, method, value);
442	if (memberValuePair != null) {	488	if (memberValuePair != null) {
443	change.addEdit(AnnotationUtils.createUpdateSingleMemberAnnotationTextEdit(singleMemberAnnotation, memberValuePair.getValue()));	489	change.addEdit(AnnotationUtils.createUpdateSingleMemberAnnotationTextEdit(singleMemberAnnotation, memberValuePair.getValue()));
Lines 451-526 Link Here
451	executeChange(new NullProgressMonitor(), change);	497	executeChange(new NullProgressMonitor(), change);
452	}	498	}
453		499
454	private ASTNode getMemberValuePairValue(AST ast, Method method, Object value) {	500	private MemberValuePair getMemberValuePair(AST ast, IMethod method, Object value) throws JavaModelException {
455	Class<?> returnType = method.getReturnType();	501	String returnType = method.getReturnType();
456	if (returnType.equals(String.class)) {	502	if (SignatureUtils.isString(returnType)) {
457	return AnnotationsCore.createStringLiteral(ast, value.toString());	503	return AnnotationsCore.createStringMemberValuePair(ast, method.getElementName(), (String) value);
458	}	504	}
459	if (returnType.equals(Boolean.TYPE)) {	505	if (SignatureUtils.isBoolean(returnType)) {
460	return AnnotationsCore.createBooleanLiteral(ast, ((Boolean) value).booleanValue());	506	return AnnotationsCore.createBooleanMemberValuePair(ast, method.getElementName(), (Boolean) value);
		507	}
		508
		509	if (SignatureUtils.isPrimitive(returnType)) {
		510	if (returnType.charAt(0) == Signature.C_BYTE
		511	\|\| returnType.charAt(0) == Signature.C_SHORT
		512	\|\| returnType.charAt(0) == Signature.C_INT
		513	\|\| returnType.charAt(0) == Signature.C_LONG
		514	\|\| returnType.charAt(0) == Signature.C_FLOAT
		515	\|\| returnType.charAt(0) == Signature.C_DOUBLE) {
		516	return AnnotationsCore.createNumberMemberValuePair(ast, method.getElementName(), value.toString());
		517	}
461	}	518	}
462	if (returnType.isPrimitive()	519
463	&& (returnType.equals(Byte.TYPE) \|\| returnType.equals(Short.TYPE)	520	if (SignatureUtils.isArray(returnType)) {
464	\|\| returnType.equals(Integer.TYPE) \|\| returnType.equals(Long.TYPE)	521	IType componentType = getComponentType(method);
465	\|\| returnType.equals(Float.TYPE) \|\| returnType.equals(Double.TYPE))) {	522	if (componentType != null) {
466	return AnnotationsCore.createNumberLiteral(ast, value.toString());	523	if (componentType.isAnnotation()) {
467	}	524	return createArrayMemberValuePair(ast, method, (Object[]) value);
468	if (returnType.isArray()) {	525	} else {
469	if (method.getReturnType().getComponentType().isAnnotation()) {	526	return AnnotationsCore.createArrayMemberValuePair(ast, method.getElementName(), (Object[]) value);
470	return createArrayValueLiteral(ast, method, (Object[]) value);	527	}
471	} else {
472	return AnnotationsCore.createArrayValueLiteral(ast, (Object[]) value);
473	}	528	}
474	}	529	}
475		530
476	if (returnType.equals(Class.class)) {	531	if (SignatureUtils.isClass(returnType)) {
477	return AnnotationsCore.createTypeLiteral(ast, value.toString());	532	return AnnotationsCore.createTypeMemberValuePair(ast, method.getElementName(), value.toString());
478	}	533	}
479		534
480	if (returnType.isEnum()) {	535	IType enumType = SignatureUtils.getEnumReturnType(method);
		536	if (enumType != null) {
481	int selected = ((Integer) value).intValue();	537	int selected = ((Integer) value).intValue();
482	if (selected != -1) {	538	if (selected != -1) {
483	return AnnotationsCore.createEnumLiteral(ast, method.getDeclaringClass().getCanonicalName(),	539	if (enumType.isMember()) {
484	method.getReturnType().getEnumConstants()[selected]);	540	return AnnotationsCore.createEnumMemberValuePair(ast, enumType.getDeclaringType().getFullyQualifiedName(),
		541	method.getElementName(), SignatureUtils.getEnumConstants(enumType)[selected]);
		542	} else {
		543	return AnnotationsCore.createEnumMemberValuePair(ast, enumType.getFullyQualifiedName(),
		544	method.getElementName(), SignatureUtils.getEnumConstants(enumType)[selected]);
		545	}
485	}	546	}
486	}	547	}
487	return null;	548	return null;
488	}	549	}
489		550
490	private MemberValuePair getMemberValuePair(AST ast, Method method, Object value) {	551	private ASTNode getMemberValuePairValue(AST ast, IMethod method, Object value) throws JavaModelException {
491	Class<?> returnType = method.getReturnType();	552	String returnType = method.getReturnType();
492	if (returnType.equals(String.class)) {	553	if (SignatureUtils.isString(returnType)) {
493	return AnnotationsCore.createStringMemberValuePair(ast, method.getName(), (String) value);	554	return AnnotationsCore.createStringLiteral(ast, value.toString());
494	}	555	}
495	if (returnType.equals(Boolean.TYPE)) {	556
496	return AnnotationsCore.createBooleanMemberValuePair(ast, method.getName(), (Boolean) value);	557	if (SignatureUtils.isBoolean(returnType)) {
497	}	558	return AnnotationsCore.createBooleanLiteral(ast, ((Boolean) value).booleanValue());
498	if (returnType.isPrimitive()	559	}
499	&& (returnType.equals(Byte.TYPE) \|\| returnType.equals(Short.TYPE)	560
500	\|\| returnType.equals(Integer.TYPE) \|\| returnType.equals(Long.TYPE)	561	if (SignatureUtils.isPrimitive(returnType)) {
501	\|\| returnType.equals(Float.TYPE) \|\| returnType.equals(Double.TYPE))) {	562	if (returnType.charAt(0) == Signature.C_BYTE
502	return AnnotationsCore.createNumberMemberValuePair(ast, method.getName(), value.toString());	563	\|\| returnType.charAt(0) == Signature.C_SHORT
503	}	564	\|\| returnType.charAt(0) == Signature.C_INT
504	if (returnType.isArray()) {	565	\|\| returnType.charAt(0) == Signature.C_LONG
505	if (method.getReturnType().getComponentType().isAnnotation()) {	566	\|\| returnType.charAt(0) == Signature.C_FLOAT
506	return createArrayMemberValuePair(ast, method, (Object[]) value);	567	\|\| returnType.charAt(0) == Signature.C_DOUBLE) {
507	} else {	568	return AnnotationsCore.createNumberLiteral(ast, value.toString());
508	return AnnotationsCore.createArrayMemberValuePair(ast, method.getName(), (Object[]) value);
509	}	569	}
510	}	570	}
511		571
512	if (returnType.equals(Class.class)) {	572	if (SignatureUtils.isArray(returnType)) {
513	return AnnotationsCore.createTypeMemberValuePair(ast, method.getName(), value.toString());	573	IType componentType = getComponentType(method);
		574	if (componentType != null) {
		575	if (componentType.isAnnotation()) {
		576	return createArrayValueLiteral(ast, method, (Object[]) value);
		577	} else {
		578	return AnnotationsCore.createArrayValueLiteral(ast, (Object[]) value);
		579	}
		580	}
		581	}
		582
		583	if (SignatureUtils.isClass(returnType)) {
		584	return AnnotationsCore.createTypeLiteral(ast, value.toString());
514	}	585	}
515		586
516	if (returnType.isEnum()) {	587
		588	IType enumType = SignatureUtils.getEnumReturnType(method);
		589	if (enumType != null) {
517	int selected = ((Integer) value).intValue();	590	int selected = ((Integer) value).intValue();
518	if (selected != -1) {	591	if (selected != -1) {
519	return AnnotationsCore.createEnumMemberValuePair(ast,	592	if (enumType.isMember()) {
520	method.getDeclaringClass().getCanonicalName(), method.getName(), method.getReturnType()	593	return AnnotationsCore.createEnumLiteral(ast, enumType.getDeclaringType().getFullyQualifiedName(),
521	.getEnumConstants()[selected]);	594	SignatureUtils.getEnumConstants(enumType)[selected]);
		595	} else {
		596	return AnnotationsCore.createEnumLiteral(ast, enumType.getFullyQualifiedName(),
		597	SignatureUtils.getEnumConstants(enumType)[selected]);
		598	}
522	}	599	}
523	}	600	}
		601
524	return null;	602	return null;
525	}	603	}
526		604
Lines 552-616 Link Here
552	annotationsView.refreshLabels();	630	annotationsView.refreshLabels();
553	}	631	}
554		632
555	private MemberValuePair createArrayMemberValuePair(AST ast, Method method, Object[] values) {	633	private MemberValuePair createArrayMemberValuePair(AST ast, IMethod method, Object[] values) throws JavaModelException {
556	return AnnotationsCore.createMemberValuePair(ast, method.getName(), createArrayValueLiteral(ast,	634	return AnnotationsCore.createMemberValuePair(ast, method.getElementName(), createArrayValueLiteral(ast,
557	method, values));	635	method, values));
558	}	636	}
559		637
560	@SuppressWarnings("unchecked")	638	private IType getComponentType(IMethod method) throws JavaModelException {
561	private ArrayInitializer createArrayValueLiteral(AST ast, Method method, Object[] values) {	639	String returnType = method.getReturnType();
		640	if (SignatureUtils.isArray(returnType)) {
		641	String elementType = Signature.getElementType(returnType);
		642	IType declaringType = method.getDeclaringType();
		643	IJavaProject javaProject = declaringType.getJavaProject();
		644	if (javaProject != null) {
		645	return javaProject.findType(Signature.toString(elementType));
		646	}
		647	}
		648	return null;
		649	}
		650
		651	private ArrayInitializer createArrayValueLiteral(AST ast, IMethod method, Object[] values) throws JavaModelException {
562	ArrayInitializer arrayInitializer = ast.newArrayInitializer();	652	ArrayInitializer arrayInitializer = ast.newArrayInitializer();
563	for (Object value : values) {	653	for (Object value : values) {
564	if (value instanceof List) {	654	if (value instanceof List<?>) {
565	Class<? extends java.lang.annotation.Annotation> annotationClass =	655	IType componentType = getComponentType(method);
566	(Class<? extends java.lang.annotation.Annotation>) method.getReturnType().getComponentType();	656	if (componentType != null) {
567		657
568	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	658	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
569		659	@SuppressWarnings("unchecked")
570	List<Map<String, Object>> valuesList = (List<Map<String, Object>>) value;	660	List<Map<String, Object>> valuesList = (List<Map<String, Object>>) value;
571	Iterator<Map<String, Object>> valuesIterator = valuesList.iterator();	661	Iterator<Map<String, Object>> valuesIterator = valuesList.iterator();
572	while (valuesIterator.hasNext()) {	662	while (valuesIterator.hasNext()) {
573	Map<String, Object> annotationMap = valuesIterator.next();	663	Map<String, Object> annotationMap = valuesIterator.next();
574	Set<Entry<String, Object>> entrySet = annotationMap.entrySet();	664	Set<Entry<String, Object>> entrySet = annotationMap.entrySet();
575	Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();	665	Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();
576	while (iterator.hasNext()) {	666	while (iterator.hasNext()) {
577	Map.Entry<java.lang.String, Object> entry = iterator.next();	667	Map.Entry<java.lang.String, Object> entry = iterator.next();
578	String memberName = entry.getKey();	668	String memberName = entry.getKey();
579	try {	669	try {
580	Method annotationMethod = annotationClass.getMethod(memberName, new Class[0]);	670	IMethod annotationMethod = componentType.getMethod(memberName, new String[] {});
581	if (annotationMethod != null) {	671	if (annotationMethod != null) {
582	Object memberValue = entry.getValue();	672	Object memberValue = entry.getValue();
583	Class<?> returnType = annotationMethod.getReturnType();	673	String returnType = annotationMethod.getReturnType();
584	if (returnType.equals(String.class)) {	674	if (SignatureUtils.isString(returnType)) {
585	memberValuePairs.add(AnnotationsCore.createStringMemberValuePair(ast, memberName,	675	memberValuePairs.add(AnnotationsCore.createStringMemberValuePair(ast, memberName,
586	memberValue.toString()));	676	memberValue.toString()));
587	}	677	}
588	if (returnType.equals(Boolean.TYPE)) {	678	if (SignatureUtils.isBoolean(returnType)) {
589	memberValuePairs.add(AnnotationsCore.createBooleanMemberValuePair(ast, memberName,	679	memberValuePairs.add(AnnotationsCore.createBooleanMemberValuePair(ast, memberName,
590	(Boolean) memberValue));	680	(Boolean) memberValue));
591	}	681	}
592	if (returnType.equals(Class.class)) {	682	if (SignatureUtils.isClass(returnType)) {
593	String className = memberValue.toString();	683	String className = memberValue.toString();
594	if (className.endsWith(".class")) {	684	if (className.endsWith(".class")) {
595	className = className.substring(0, className.lastIndexOf("."));	685	className = className.substring(0, className.lastIndexOf("."));
		686	}
		687	memberValuePairs.add(AnnotationsCore.createMemberValuePair(ast, memberName,
		688	AnnotationsCore.createTypeLiteral(ast, className)));
596	}	689	}
597	memberValuePairs.add(AnnotationsCore.createMemberValuePair(ast, memberName,	690	// if (returnType.isPrimitive()) {
598	AnnotationsCore.createTypeLiteral(ast, className)));	691	// memberValuePairs.add(getNumberMemberValuePair(ast, memberName, memberValue));
		692	// }
599	}	693	}
600	// if (returnType.isPrimitive()) {
601	// memberValuePairs.add(getNumberMemberValuePair(ast, memberName, memberValue));
602	// }
603	}
604		694
605	} catch (SecurityException se) {	695	} catch (SecurityException se) {
606	AnnotationsCorePlugin.log(se);	696	AnnotationsCorePlugin.log(se);
607	} catch (NoSuchMethodException nsme) {	697	}
608	AnnotationsCorePlugin.log(nsme);
609	}	698	}
610	}	699	}
		700	arrayInitializer.expressions().add(AnnotationsCore.createNormalAnnotation(ast, componentType.getFullyQualifiedName(),
		701	memberValuePairs));
611	}	702	}
612	arrayInitializer.expressions().add(AnnotationsCore.createNormalAnnotation(ast, annotationClass.getCanonicalName(),
613	memberValuePairs));
614	}	703	}
615	}	704	}
616	return arrayInitializer;	705	return arrayInitializer;




 *******************************************************************************/
package org.eclipse.jst.ws.internal.jaxws.ui.views;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;


        annotationTreeViewer.setComparator(new ViewerComparator() {
            @Override
            public int compare(Viewer viewer, Object obj1, Object obj2) {
                if (obj1 instanceof IType && obj2 instanceof IType) {
                    return ((IType) obj1).getFullyQualifiedName().compareTo(
                            ((IType) obj2).getFullyQualifiedName());
                            ((Class<? extends java.lang.annotation.Annotation>) obj2).getCanonicalName());
                }
                if (obj1 instanceof IMethod && obj2 instanceof IMethod) {
                    return ((IMethod) obj1).getElementName().compareTo(((IMethod) obj2).getElementName());
                }
                return super.compare(viewer, obj1, obj2);
            }




 *******************************************************************************/
package org.eclipse.jst.ws.internal.jaxws.ui.views;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.jdt.core.IType;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;


    @Override
    public boolean select(Viewer viewer, Object parentElement, Object element) {
    	if (element instanceof IType) {
    		AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForType((IType) element);
                getAnnotationDefinitionForClass((Class<? extends Annotation>)element);
            if (annotationDefinition != null) {
                return !categories.contains(annotationDefinition.getCategory());
            }
    	}
        return true;
    }





package org.eclipse.jst.ws.internal.jaxws.ui.views;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jst.ws.annotations.core.AnnotationsManager;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;

public class AnnotationsViewContentProvider implements ITreeContentProvider {

    public Object[] getChildren(Object parentElement) {
        if (parentElement instanceof IType) {
            try {
                return ((IType) parentElement).getMethods();
            } catch (JavaModelException jme) {
                JAXWSUIPlugin.log(jme.getStatus());
            }
        }
        return new Object[] {};
    }

    public Object getParent(Object element) {
        return null;
    }

    public boolean hasChildren(Object element) {
        if (element instanceof IType) {
            try {
                return ((IType) element).getMethods().length > 0;
            } catch (JavaModelException jme) {
                JAXWSUIPlugin.log(jme.getStatus());
            }
        }
        return false;
    }

    public Object[] getElements(Object inputElement) {
        if (inputElement != null && inputElement instanceof IJavaElement && ((IJavaElement) inputElement).exists()) {
            IJavaElement javaElement = (IJavaElement) inputElement;
            return AnnotationsManager.getAnnotationTypes(javaElement).toArray();
        }
        return new Object[] {};
    }

    public void dispose() {

    }

    public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
    }

}

Lines 56-62 Link Here

(-)src/org/eclipse/jst/ws/internal/jaxws/ui/views/ClassDialogCellEditor.java (-1 / +1 lines)
56		56
57	@Override	57	@Override
58	protected void updateContents(Object value) {	58	protected void updateContents(Object value) {
59	if (value != null) {	59	if (value != null && value.toString().trim().length() > 0) {
60	getDefaultLabel().setText(value.toString() + ".class"); //$NON-NLS-1$	60	getDefaultLabel().setText(value.toString() + ".class"); //$NON-NLS-1$
61	} else {	61	} else {
62	getDefaultLabel().setText(""); //$NON-NLS-1$	62	getDefaultLabel().setText(""); //$NON-NLS-1$

Return to bug 325364

Lines 68-76 Link Here

(-)src/org/eclipse/jst/ws/annotations/core/AnnotationsManager.java (-30 / +64 lines)
68	private static final String ATT_NAME = "name"; //$NON-NLS-1$	68	private static final String ATT_NAME = "name"; //$NON-NLS-1$
69	private static final String ATT_CATEGORY = "category"; //$NON-NLS-1$	69	private static final String ATT_CATEGORY = "category"; //$NON-NLS-1$
70		70
71	// private static final String ELEM_TARGET_FILTER = "targetFilter"; //$NON-NLS-1$
72	// private static final String ATT_TARGET = "target"; //$NON-NLS-1$
73
74	private AnnotationsManager() {	71	private AnnotationsManager() {
75	}	72	}
76		73
Lines 102-107 Link Here
102	}	99	}
103		100
104	/**	101	/**
		102	* Returns a list of all the contributed annotations that target the given {@link org.eclipse.jdt.core.IJavaElement}.
		103	*
		104	* @param element one of
		105	* <li>org.eclipse.jdt.core.IPackageDeclaration</li>
		106	* <li>org.eclipse.jdt.core.IType</li>
		107	* <li>org.eclipse.jdt.core.IField</li>
		108	* <li>org.eclipse.jdt.core.IMethod</li>
		109	* <li>org.eclipse.jdt.core.ILocalVariable</li>
		110	*
		111	* @return a list of types which represent annotation types.
		112	* @since 1.1
		113	*/
		114	public static List<IType> getAnnotationTypes(IJavaElement javaElement) {
		115	List<IType> annotations = new ArrayList<IType>();
		116
		117	try {
		118	List<AnnotationDefinition> annotationDefinitions = getAllAnnotationsForElement(javaElement);
		119
		120	filterAnnotationsList(javaElement, annotationDefinitions);
		121
		122	for (AnnotationDefinition annotationDefinition : annotationDefinitions) {
		123	IType type = annotationDefinition.getAnnotationType();
		124	if (type != null) {
		125	annotations.add(type);
		126	}
		127	}
		128	} catch (JavaModelException jme) {
		129	AnnotationsCorePlugin.log(jme.getStatus());
		130	}
		131	return annotations;
		132	}
		133
		134	/**
105	* Returns a list of all the contributed {@link java.lang.annotation.Annotation} that target the given java element type.	135	* Returns a list of all the contributed {@link java.lang.annotation.Annotation} that target the given java element type.
106	*	136	*
107	* @param element one of	137	* @param element one of
Lines 112-118 Link Here
112	* <li>org.eclipse.jdt.core.ILocalVariable</li>	142	* <li>org.eclipse.jdt.core.ILocalVariable</li>
113	*	143	*
114	* @return a list of annotations.	144	* @return a list of annotations.
		145	* @deprecated As of 1.1 replaced by {@link #getAnnotationTypes(IJavaElement)}}
115	*/	146	*/
		147	@Deprecated
116	public static List<Class<? extends Annotation>> getAnnotations(IJavaElement javaElement) {	148	public static List<Class<? extends Annotation>> getAnnotations(IJavaElement javaElement) {
117	List<Class<? extends Annotation>> annotations = new ArrayList<Class<? extends Annotation>>();	149	List<Class<? extends Annotation>> annotations = new ArrayList<Class<? extends Annotation>>();
118		150
Lines 131-147 Link Here
131	}	163	}
132		164
133	private static synchronized Map<String, AnnotationDefinition> getAnnotationToClassNameDefinitionMap() {	165	private static synchronized Map<String, AnnotationDefinition> getAnnotationToClassNameDefinitionMap() {
134
135	if (annotationClassNameToDefinitionMap == null) {	166	if (annotationClassNameToDefinitionMap == null) {
136	List<AnnotationDefinition> annotationDefinitions = getAnnotations();	167	List<AnnotationDefinition> annotationDefinitions = getAnnotations();
137		168
138	annotationClassNameToDefinitionMap = new HashMap<String, AnnotationDefinition>();	169	annotationClassNameToDefinitionMap = new HashMap<String, AnnotationDefinition>();
139		170
140	for (AnnotationDefinition annotationDefinition : annotationDefinitions) {	171	for (AnnotationDefinition annotationDefinition : annotationDefinitions) {
141	if (annotationDefinition.getAnnotationClass() != null) {	172	if (annotationDefinition.getAnnotationClassName() != null) {
142	annotationClassNameToDefinitionMap.put(annotationDefinition.getAnnotationClass()	173	annotationClassNameToDefinitionMap.put(annotationDefinition.getAnnotationClassName(), annotationDefinition);
143	.getCanonicalName(), annotationDefinition);	174	}
144	}
145	}	175	}
146	}	176	}
147	return annotationClassNameToDefinitionMap;	177	return annotationClassNameToDefinitionMap;
Lines 195-200 Link Here
195	}	225	}
196		226
197	/**	227	/**
		228	* Returns the {@link AnnotationDefinition} for the given {@link org.eclipse.jdt.core.IType}
		229	* or null if no annotation definition can be found.
		230	*
		231	* @param annotationType an <code>org.eclipse.jdt.core.IType</code> which represents an annotation type.
		232	* @return the annotation definition for the <code>org.eclipse.jdt.core.IType</code>.
		233	* @since 1.1
		234	*/
		235	public static AnnotationDefinition getAnnotationDefinitionForType(IType annotationType) {
		236	return getAnnotationToClassNameDefinitionMap().get(annotationType.getFullyQualifiedName());
		237	}
		238
		239	/**
198	* Returns the {@link IAnnotationAttributeInitializer} for the given {@link org.eclipse.jdt.core.dom.Name}	240	* Returns the {@link IAnnotationAttributeInitializer} for the given {@link org.eclipse.jdt.core.dom.Name}
199	* or null if none can be found.	241	* or null if none can be found.
200	* @param name a {@link SimpleName} or {@link QualifiedName} for the annotation to search for.	242	* @param name a {@link SimpleName} or {@link QualifiedName} for the annotation to search for.
Lines 254-260 Link Here
254	if (annotationCategoryCache != null) {	296	if (annotationCategoryCache != null) {
255	return annotationCategoryCache;	297	return annotationCategoryCache;
256	}	298	}
257
258	annotationCategoryCache = new HashMap<String, String>();	299	annotationCategoryCache = new HashMap<String, String>();
259		300
260	IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(	301	IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(
Lines 274-280 Link Here
274	if (annotationInitializerCache != null) {	315	if (annotationInitializerCache != null) {
275	return annotationInitializerCache;	316	return annotationInitializerCache;
276	}	317	}
277
278	annotationInitializerCache = new HashMap<String, IConfigurationElement>();	318	annotationInitializerCache = new HashMap<String, IConfigurationElement>();
279		319
280	IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(	320	IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(
Lines 326-366 Link Here
326	return ""; //$NON-NLS-1$	366	return ""; //$NON-NLS-1$
327	}	367	}
328		368
329	private static List<AnnotationDefinition> getAllAnnotationsForElement(IJavaElement javaElement)	369	private static List<AnnotationDefinition> getAllAnnotationsForElement(IJavaElement javaElement) throws JavaModelException {
330	throws JavaModelException {
331
332	if (javaElement instanceof IPackageDeclaration) {	370	if (javaElement instanceof IPackageDeclaration) {
333	return getAnnotationsForElementType(ElementType.PACKAGE);	371	return getAnnotationsForElementType(javaElement, ElementType.PACKAGE);
334	}	372	}
335		373
336	if (javaElement instanceof IType) {	374	if (javaElement instanceof IType) {
337	IType type = (IType) javaElement;	375	IType type = (IType) javaElement;
338	if (type.isAnnotation()) {	376	if (type.isAnnotation()) {
339	return getAnnotationsForElementType(ElementType.ANNOTATION_TYPE);	377	return getAnnotationsForElementType(javaElement, ElementType.ANNOTATION_TYPE);
340	}	378	}
341	return getAnnotationsForElementType(ElementType.TYPE);	379	return getAnnotationsForElementType(javaElement, ElementType.TYPE);
342	}	380	}
343		381
344	if (javaElement instanceof IField) {	382	if (javaElement instanceof IField) {
345	return getAnnotationsForElementType(ElementType.FIELD);	383	return getAnnotationsForElementType(javaElement, ElementType.FIELD);
346	}	384	}
347		385
348	if (javaElement instanceof IMethod) {	386	if (javaElement instanceof IMethod) {
349	return getAnnotationsForElementType(ElementType.METHOD);	387	return getAnnotationsForElementType(javaElement, ElementType.METHOD);
350	}	388	}
351		389
352	if (javaElement instanceof ILocalVariable) {	390	if (javaElement instanceof ILocalVariable) {
353	return getAnnotationsForElementType(ElementType.PARAMETER);	391	return getAnnotationsForElementType(javaElement, ElementType.PARAMETER);
354	}	392	}
355		393
356	if (javaElement instanceof IAnnotation) {	394	if (javaElement instanceof IAnnotation) {
357	return getAnnotationsForElementType(ElementType.ANNOTATION_TYPE);	395	return getAnnotationsForElementType(javaElement, ElementType.ANNOTATION_TYPE);
358	}	396	}
359		397
360	return Collections.emptyList();	398	return Collections.emptyList();
361	}	399	}
362		400
363	private static List<AnnotationDefinition> getAnnotationsForElementType(ElementType elementType) {	401	private static List<AnnotationDefinition> getAnnotationsForElementType(IJavaElement javaElement, ElementType elementType) {
364	List<AnnotationDefinition> annotationDefinitions = new ArrayList<AnnotationDefinition>();	402	List<AnnotationDefinition> annotationDefinitions = new ArrayList<AnnotationDefinition>();
365		403
366	if (annotationCache == null) {	404	if (annotationCache == null) {
Lines 368-375 Link Here
368	}	406	}
369		407
370	for (AnnotationDefinition annotationDefinition : annotationCache) {	408	for (AnnotationDefinition annotationDefinition : annotationCache) {
371	if (annotationDefinition.getTargets().contains(elementType) &&	409	annotationDefinition.setJavaProject(javaElement.getJavaProject());
372	!isDeprecated(annotationDefinition)) {	410
		411	if (annotationDefinition.getAnnotationTypeTargets().contains(elementType) &&
		412	!annotationDefinition.isDeprecated()) {
373	annotationDefinitions.add(annotationDefinition);	413	annotationDefinitions.add(annotationDefinition);
374	}	414	}
375	}	415	}
Lines 396-402 Link Here
396	annotationIter.remove();	436	annotationIter.remove();
397	}	437	}
398	if (method.isConstructor()	438	if (method.isConstructor()
399	&& !annotationDefinition.getTargets().contains(ElementType.CONSTRUCTOR)) {	439	&& !annotationDefinition.getAnnotationTypeTargets().contains(ElementType.CONSTRUCTOR)) {
400	annotationIter.remove();	440	annotationIter.remove();
401	}	441	}
402		442
Lines 464-473 Link Here
464	}	504	}
465	return false;	505	return false;
466	}	506	}
467
468	//TODO Move the Deprecated option to preferences
469	private static boolean isDeprecated(AnnotationDefinition annotationDefinition) {
470	Class<?> annotationClass = annotationDefinition.getAnnotationClass();
471	return annotationClass.getAnnotation(java.lang.Deprecated.class) != null;
472	}
473	}	507	}

Added Link Here

(-)src/org/eclipse/jst/ws/internal/annotations/core/utils/SignatureUtils.java (+124 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 Shane Clarke.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Shane Clarke - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jst.ws.internal.annotations.core.utils;
12
13	import java.util.ArrayList;
14	import java.util.List;
15
16	import org.eclipse.jdt.core.IField;
17	import org.eclipse.jdt.core.IMethod;
18	import org.eclipse.jdt.core.IType;
19	import org.eclipse.jdt.core.JavaModelException;
20	import org.eclipse.jdt.core.Signature;
21
22	public final class SignatureUtils {
23
24	private SignatureUtils() {
25	}
26
27	public static boolean isString(String returnType) {
28	int signatureKind = Signature.getTypeSignatureKind(returnType);
29	if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
30	if (returnType.charAt(0) == Signature.C_RESOLVED) {
31	return Signature.toString(returnType).equals(java.lang.String.class.getCanonicalName());
32	}
33	if (returnType.charAt(0) == Signature.C_UNRESOLVED) {
34	return Signature.toString(returnType).equals(java.lang.String.class.getSimpleName());
35	}
36	}
37	return false;
38	}
39
40	public static boolean isClass(String returnType) {
41	int signatureKind = Signature.getTypeSignatureKind(returnType);
42	if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
43	if (returnType.charAt(0) == Signature.C_RESOLVED) {
44	returnType = Signature.getTypeErasure(returnType);
45	return Signature.toString(returnType).equals(java.lang.Class.class.getCanonicalName());
46	}
47	if (returnType.charAt(0) == Signature.C_UNRESOLVED) {
48	returnType = Signature.getTypeErasure(returnType);
49	return Signature.toString(returnType).equals(java.lang.Class.class.getSimpleName());
50	}
51	}
52	return false;
53	}
54
55	public static boolean isBoolean(String returnType) {
56	int signatureKind = Signature.getTypeSignatureKind(returnType);
57	if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
58	if (returnType.charAt(0) == Signature.C_RESOLVED) {
59	return Signature.toString(returnType).equals(java.lang.Boolean.class.getCanonicalName());
60	}
61	if (returnType.charAt(0) == Signature.C_UNRESOLVED) {
62	return Signature.toString(returnType).equals(java.lang.Boolean.class.getSimpleName());
63	}
64	}
65	if (signatureKind == Signature.BASE_TYPE_SIGNATURE) {
66	return returnType.charAt(0) == Signature.C_BOOLEAN;
67	}
68	return false;
69	}
70
71	public static boolean isArray(String returnType) {
72	return Signature.getTypeSignatureKind(returnType) == Signature.ARRAY_TYPE_SIGNATURE;
73	}
74
75	public static boolean isPrimitive(String returnType) {
76	return Signature.getTypeSignatureKind(returnType) == Signature.BASE_TYPE_SIGNATURE;
77	}
78
79	public static boolean isEnum(IMethod method) throws JavaModelException {
80	return getEnumReturnType(method) != null;
81	}
82
83	public static IType getEnumReturnType(IMethod method) throws JavaModelException {
84	String returnType = method.getReturnType();
85	int signatureKind = Signature.getTypeSignatureKind(returnType);
86	if (signatureKind == Signature.CLASS_TYPE_SIGNATURE) {
87	if (returnType.charAt(0) == Signature.C_RESOLVED) {
88	IType type = method.getJavaProject().findType(Signature.toString(returnType));
89	if (type != null && type.isEnum()) {
90	return type;
91	}
92	}
93	}
94	return null;
95	}
96
97	public static String[] getEnumConstantsNames(IType enumType) throws JavaModelException {
98	if (enumType.isEnum()) {
99	List<String> enumConstants = new ArrayList<String>();
100	IField[] fields = getEnumConstants(enumType);
101	for (IField field : fields) {
102	enumConstants.add(field.getElementName());
103	}
104	return enumConstants.toArray(new String[enumConstants.size()]);
105	}
106	return new String[] {};
107	}
108
109	public static IField[] getEnumConstants(IType enumType) throws JavaModelException {
110	if (enumType.isEnum()) {
111	List<IField> enumConstants = new ArrayList<IField>();
112	IField[] fields = enumType.getFields();
113	for (IField field : fields) {
114	if (field.isEnumConstant()) {
115	enumConstants.add(field);
116	}
117	}
118	return enumConstants.toArray(new IField[enumConstants.size()]);
119	}
120	return new IField[] {};
121	}
122
123
124	}

Lines 40-45 Link Here

(-)src/org/eclipse/jst/ws/internal/cxf/core/utils/CXFModelUtils.java (-8 / +10 lines)
40	import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;	40	import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
41	import org.eclipse.jdt.ui.CodeStyleConfiguration;	41	import org.eclipse.jdt.ui.CodeStyleConfiguration;
42	import org.eclipse.jdt.ui.SharedASTProvider;	42	import org.eclipse.jdt.ui.SharedASTProvider;
		43	import org.eclipse.jst.ws.annotations.core.AnnotationDefinition;
43	import org.eclipse.jst.ws.annotations.core.AnnotationsCore;	44	import org.eclipse.jst.ws.annotations.core.AnnotationsCore;
44	import org.eclipse.jst.ws.annotations.core.AnnotationsManager;	45	import org.eclipse.jst.ws.annotations.core.AnnotationsManager;
45	import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;	46	import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;
Lines 124-136 Link Here
124	} else {	125	} else {
125	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	126	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
126		127
127	IAnnotationAttributeInitializer annotationAttributeInitializer =	128	AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForClass(WebService.class.getCanonicalName());
128	AnnotationsManager.getAnnotationDefinitionForClass(WebService.class).	129	IAnnotationAttributeInitializer annotationAttributeInitializer = annotationDefinition.getAnnotationAttributeInitializer();
129	getAnnotationAttributeInitializer();
130		130
		131	IType annotationType = annotationDefinition.getAnnotationType();
131	if (annotationAttributeInitializer != null) {	132	if (annotationAttributeInitializer != null) {
132	memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(type, ast,	133	memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(type, ast, annotationType);
133	WebService.class);
134	}	134	}
135		135
136	if (model.isUseServiceEndpointInterface() && type.isClass()) {	136	if (model.isUseServiceEndpointInterface() && type.isClass()) {
Lines 218-228 Link Here
218		218
219	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	219	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
220		220
221	IAnnotationAttributeInitializer annotationAttributeInitializer = AnnotationsManager	221	AnnotationDefinition annotationDefinition = AnnotationsManager.getAnnotationDefinitionForClass(annotationClass.getCanonicalName());
222	.getAnnotationDefinitionForClass(annotationClass).getAnnotationAttributeInitializer();	222	IAnnotationAttributeInitializer annotationAttributeInitializer = annotationDefinition.getAnnotationAttributeInitializer();
		223
		224	IType annotationType = annotationDefinition.getAnnotationType();
223		225
224	if (annotationAttributeInitializer != null) {	226	if (annotationAttributeInitializer != null) {
225	memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(javaElement, ast, annotationClass);	227	memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(javaElement, ast, annotationType);
226	}	228	}
227		229
228	return AnnotationsCore.createNormalAnnotation(ast, annotationClass.getSimpleName(), memberValuePairs);	230	return AnnotationsCore.createNormalAnnotation(ast, annotationClass.getSimpleName(), memberValuePairs);

Lines 17-31 Link Here

(-)plugin.xml (-10 / +1 lines)
17	category="jaxb.category"	17	category="jaxb.category"
18	class="javax.xml.bind.annotation.XmlAccessorType"	18	class="javax.xml.bind.annotation.XmlAccessorType"
19	name="XmlAccessorType"/>	19	name="XmlAccessorType"/>
20
21	<!-- TODO Reinstate when XmlAdapter issue is solved
22	<annotation
23	category="jaxb.category"
24	class="javax.xml.bind.annotation.adapters.XmlAdapter"
25	name="XmlAdapter">
26	</annotation>
27	-->
28
29	<annotation	20	<annotation
30	category="jaxb.category"	21	category="jaxb.category"
31	class="javax.xml.bind.annotation.XmlAnyAttribute"	22	class="javax.xml.bind.annotation.XmlAnyAttribute"
Lines 177-181 Link Here
177	name="XmlValue">	168	name="XmlValue">
178	</annotation>	169	</annotation>
179	</extension>	170	</extension>
180		171
181	</plugin>	172	</plugin>

Lines 6-12 Link Here

(-)META-INF/MANIFEST.MF (-2 / +1 lines)
6	Bundle-Version: 1.0.100.qualifier	6	Bundle-Version: 1.0.100.qualifier
7	Bundle-ClassPath: .	7	Bundle-ClassPath: .
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Eclipse-RegisterBuddy: org.eclipse.jst.ws.annotations.core
10	Bundle-RequiredExecutionEnvironment: J2SE-1.5	9	Bundle-RequiredExecutionEnvironment: J2SE-1.5
11	Bundle-Activator: org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin	10	Bundle-Activator: org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin
12	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)",	11	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)",
Lines 14-20 Link Here
14	org.eclipse.core.resources;bundle-version="[3.4.0,4.0.0)",	13	org.eclipse.core.resources;bundle-version="[3.4.0,4.0.0)",
15	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",	14	org.eclipse.jdt.apt.core;bundle-version="[3.3.100,4.0.0)",
16	org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)",	15	org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)",
17	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.1.0)",	16	org.eclipse.jst.ws.annotations.core;bundle-version="[1.0.0,1.2.0)",
18	javax.wsdl;bundle-version="[1.6.2,1.7.0)",	17	javax.wsdl;bundle-version="[1.6.2,1.7.0)",
19	javax.xml.soap;bundle-version="[1.2.0,1.3.0)",	18	javax.xml.soap;bundle-version="[1.2.0,1.3.0)",
20	org.apache.xerces;bundle-version="[2.9.0,3.0.0)",	19	org.apache.xerces;bundle-version="[2.9.0,3.0.0)",