Attachment #191966 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.Set;

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().trim());
                    }
                }
                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;




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

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

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.ILocalVariable;
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.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.Annotation;

import org.eclipse.jst.ws.annotations.core.AnnotationsManager;
import org.eclipse.jst.ws.annotations.core.initialization.IAnnotationAttributeInitializer;
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.JAXWSUIMessages;
import org.eclipse.jst.ws.internal.jaxws.ui.JAXWSUIPlugin;
import org.eclipse.ltk.core.refactoring.Change;

import org.eclipse.text.edits.MultiTextEdit;

public class AnnotationsValuesEditingSupport extends EditingSupport {

    private AnnotationsView annotationsView;
    private TreeViewer treeViewer;



    @Override
    protected boolean canEdit(Object element) {
        if (element instanceof IMethod) {
            IMethod method = (IMethod) element;
            return (Boolean) getValue(method.getDeclaringType());
        }
        return true;
    }

    @Override
    protected CellEditor getCellEditor(Object element) {
        if (element instanceof IType) {
            return checkboxCellEditor;
        }
        if (element instanceof IMethod) {
            try {
                IMethod method = (IMethod) element;

                IType enumType = SignatureUtils.getEnumReturnType(method);
                if (enumType != null) {
                    comboBoxCellEditor.setItems(SignatureUtils.getEnumConstantsNames(enumType));
                    return comboBoxCellEditor;
                }

                final String returnType = method.getReturnType();

                if (SignatureUtils.isBoolean(returnType)) {
                    return checkboxCellEditor;
                }

                if (SignatureUtils.isClass(returnType)) {
                    return classDialogCellEditor;
                }

                if (SignatureUtils.isArray(returnType)) {
                    annotationArrayCellEditor.setMethod(method);
                    return annotationArrayCellEditor;
                }
                if (SignatureUtils.isPrimitive(returnType)) {
                    textCellEditor.setValidator(new ICellEditorValidator() {
                        public String isValid(Object value) {
                            try {
                                if (returnType.charAt(0) == Signature.C_BYTE) {
                                    Byte.parseByte((String) value);
                                }
                                if (returnType.charAt(0) == Signature.C_SHORT) {
                                    Short.parseShort((String) value);
                                }
                                if (returnType.charAt(0) == Signature.C_INT) {
                                    Integer.parseInt((String) value);
                                }
                                if (returnType.charAt(0) == Signature.C_LONG) {
                                    Long.parseLong((String) value);
                                }
                                if (returnType.charAt(0) == Signature.C_FLOAT) {
                                    Float.parseFloat((String) value);
                                }
                                if (returnType.charAt(0) == Signature.C_DOUBLE) {
                                    Double.parseDouble((String) value);
                                }
                            } catch (NumberFormatException nfe) {
                                return JAXWSUIMessages.ANNOTATION_EDITING_SUPPORT_NOT_VALID_MESSAGE_PREFIX + value;
                            }
                            return null;
                            return JAXWSUIMessages.ANNOTATION_EDITING_SUPPORT_NOT_VALID_MESSAGE_PREFIX
                            + returnType.getSimpleName();
                        }
                    });
                    return textCellEditor;
                }
                return textCellEditor;
            } catch (JavaModelException jme) {
                JAXWSUIPlugin.log(jme.getStatus());
            }
            return textCellEditor;
        }
        return checkboxCellEditor;
    }

    @Override
    protected Object getValue(Object element) {
        if (element instanceof IType) {
            return getValueForClass((IType) element);
        }
        if (element instanceof IMethod) {
            return getValueForMethod((IMethod) element);
        }
        return null;
    }

    private Object getValueForClass(IType type) {
        if (treeViewer.getInput() instanceof IAnnotatable) {
            return getValueForClass(type, (IAnnotatable) treeViewer.getInput());
        }
        return Boolean.FALSE;
    }

    private Object getValueForClass(IType type, IAnnotatable annotatedElement) {
        if (annotatedElement instanceof ILocalVariable) {
            ILocalVariable localVariable = getLocalVariable(annotatedElement);
            if (localVariable != null) {

            for (IAnnotation annotation : annotations) {
                String annotationName = annotation.getElementName();
                if (AnnotationUtils.isAnnotationPresent((IJavaElement)annotatedElement, annotationName)
                        && (annotationName.equals(type.getElementName())
                                || annotationName.equals(type.getFullyQualifiedName()))) {
                    return Boolean.TRUE;
                }
            }

        return Boolean.FALSE;
    }

    private Object getValueForMethod(IMethod method) {
        Object value = null;
        try {
            if (treeViewer.getInput() instanceof IAnnotatable) {

        return value;
    }

    private Object getValueForMethod(IMethod method, IAnnotatable annotatedElement) throws JavaModelException {
        if (annotatedElement instanceof ILocalVariable) {
            ILocalVariable localVariable = getLocalVariable(annotatedElement);
            if (localVariable != null) {
                annotatedElement = localVariable;
            }
        }
        String returnType = method.getReturnType();
        IAnnotation[] annotations = annotatedElement.getAnnotations();
        for (IAnnotation annotation : annotations) {
            IType declaringType = method.getDeclaringType();

            String annotationName = annotation.getElementName();
            if (annotationName.equals(declaringType.getElementName())
                    || annotationName.equals(declaringType.getFullyQualifiedName())) {
                IMemberValuePair[] memberValuePairs = annotation.getMemberValuePairs();
                for (IMemberValuePair memberValuePair : memberValuePairs) {
                    if (memberValuePair.getMemberName().equals(method.getElementName())) {
                        if (SignatureUtils.isString(returnType)) {
                            return memberValuePair.getValue();
                        }

                        IType enumType = SignatureUtils.getEnumReturnType(method);
                        if (enumType != null) {
                            String enumValue = memberValuePair.getValue().toString();
                            String literal = enumValue.substring(enumValue.lastIndexOf(".") + 1); //$NON-NLS-1$
                            String[] enumConstants = SignatureUtils.getEnumConstantsNames(enumType);
                            for (int i = 0; i < enumConstants.length; i++) {
                                if (enumConstants[i].equals(literal)) {
                                    return i;
                                }
                            }
                        }
                        if (SignatureUtils.isClass(returnType)) {
                        if (returnType.equals(Class.class)) {
                            return memberValuePair.getValue();
                        }

                        if (SignatureUtils.isBoolean(returnType)) {
                            return memberValuePair.getValue();
                        }

                        if (SignatureUtils.isPrimitive(returnType)) {
                            return ""; //$NON-NLS-1$
                        }
                        if (SignatureUtils.isArray(returnType)) {
                            if (memberValuePair.getValueKind() == IMemberValuePair.K_CLASS) {
                                Object[] arrayValues = (Object[])memberValuePair.getValue();
                                for (int i = 0; i < arrayValues.length; i++) {

                        }
                    }
                }
                return getDefaultValueForMethod(method);
            }
        }
        return null;
    }

    private Object getDefaultValueForMethod(IMethod method) throws JavaModelException {
        String returnType = method.getReturnType();

        if (SignatureUtils.isString(returnType)) {
            return ""; //$NON-NLS-1$
        }

        if (SignatureUtils.isBoolean(returnType)) {
            return Boolean.FALSE;
        }

        if (SignatureUtils.isEnum(method)) {
            return -1;
        }

        if (SignatureUtils.isPrimitive(returnType)) {
            return ""; //$NON-NLS-1$
        }

        if (SignatureUtils.isArray(returnType)) {
            return new Object[] {};
        }

        return null;
    }


        }

        try {
            if (element instanceof IType && ((IType) element).isAnnotation()) {
                setValueForClass((IType) element, (Boolean) value);
                Class<? extends java.lang.annotation.Annotation> annotationClass =
                    (Class<? extends java.lang.annotation.Annotation>) element;
                if (annotationClass != null) {
                    setValueForClass(annotationClass, (Boolean) value);
                }
            }

            if (element instanceof IMethod) {
                setValueForMethod((IMethod) element, value);
            }
        } catch (CoreException ce) {
            JAXWSUIPlugin.log(ce.getStatus());
        }
    }

    private void setValueForClass(IType type, Boolean annotate) throws CoreException {
            Boolean annotate) throws CoreException {
        Object viewerInput = treeViewer.getInput();

        IAnnotationAttributeInitializer annotationAttributeInitializer =
            AnnotationsManager.getAnnotationDefinitionForClass(type.getFullyQualifiedName()).getAnnotationAttributeInitializer();

        if (viewerInput instanceof IJavaElement) {
            setValueForClass(type, annotate, (IJavaElement) viewerInput, annotationAttributeInitializer);
        }
    }

    private Annotation getAnnotation(AST ast, IType type, List<MemberValuePair> memberValuePairs) throws JavaModelException {
            List<MemberValuePair> memberValuePairs) {

        Annotation annotation =  null;
        int numberOfDeclaredMethods = type.getMethods().length;
        if (numberOfDeclaredMethods == 0) {
            annotation = AnnotationsCore.createMarkerAnnotation(ast, type.getElementName());
        } else if (numberOfDeclaredMethods == 1) {
            Expression value = null;
            if (memberValuePairs != null && memberValuePairs.size() == 1) {

                }
            }
            if (value != null) {
                annotation = AnnotationsCore.createSingleMemberAnnotation(ast, type.getElementName(), value);
            } else {
                annotation = AnnotationsCore.createNormalAnnotation(ast, type.getElementName(), memberValuePairs);
            }
        } else if (numberOfDeclaredMethods > 1) {
            annotation = AnnotationsCore.createNormalAnnotation(ast, type.getElementName(), memberValuePairs);
        }

        return annotation;
    }

    private void setValueForClass(IType type, Boolean annotate, IJavaElement javaElement,
            IAnnotationAttributeInitializer annotationAttributeInitializer) throws CoreException {
    throws CoreException {
        ICompilationUnit source = AnnotationUtils.getCompilationUnitFromJavaElement(javaElement);
        CompilationUnit compilationUnit = SharedASTProvider.getAST(source, SharedASTProvider.WAIT_YES, null);
        AST ast = compilationUnit.getAST();

        List<MemberValuePair> memberValuePairs = getMemberValuePairs(annotationAttributeInitializer, javaElement,
                ast, type);

        Annotation annotation = getAnnotation(ast, type, memberValuePairs);

        TextFileChange change = new TextFileChange("Add/Remove Annotation", (IFile) source.getResource()); //$NON-NLS-1$
        MultiTextEdit multiTextEdit = new MultiTextEdit();

                    || javaElement.getElementType() == IJavaElement.FIELD
                    || javaElement.getElementType() == IJavaElement.METHOD
                    || javaElement.getElementType() == IJavaElement.LOCAL_VARIABLE) {
                change.addEdit(AnnotationUtils.createAddImportTextEdit(javaElement, type.getFullyQualifiedName()));
                change.addEdit(AnnotationUtils.createAddAnnotationTextEdit(javaElement, annotation));
            }
        } else {

                    || javaElement.getElementType() == IJavaElement.FIELD
                    || javaElement.getElementType() == IJavaElement.METHOD
                    || javaElement.getElementType() == IJavaElement.LOCAL_VARIABLE) {
                change.addEdit(AnnotationUtils.createRemoveImportTextEdit(javaElement, type.getFullyQualifiedName()));
                change.addEdit(AnnotationUtils.createRemoveAnnotationTextEdit(javaElement, annotation));
            }
        }
        executeChange(new NullProgressMonitor(), change);
    }

    private List<MemberValuePair> getMemberValuePairs(IAnnotationAttributeInitializer annotationAttributeInitializer,
            IJavaElement javaElement, AST ast, IType type) {
            Class<?extends java.lang.annotation.Annotation> annotationClass) {
        if (annotationAttributeInitializer != null) {
            List<MemberValuePair> memberValuePairs = annotationAttributeInitializer.getMemberValuePairs(javaElement, ast, type);
            if (memberValuePairs.size() > 0) {
                return memberValuePairs;
            } else {
                return annotationAttributeInitializer.getMemberValuePairs(javaElement, ast,
                        AnnotationsManager.getAnnotationDefinitionForType(type).getAnnotationClass());
            }
        }
        return Collections.emptyList();
    }

    private void setValueForMethod(IMethod method, Object value) throws CoreException {
        if (value instanceof String) {
            Object currentValue = getValue(method);
            if (currentValue != null && currentValue instanceof String) {
                if (((String) value).equals(currentValue)) {
                    return;
                }
            }
        }
        if (((Boolean) getValue(method.getDeclaringType())).booleanValue()) {
            Object viewerInput = treeViewer.getInput();
            if (viewerInput instanceof IAnnotatable) {
                setValueForMethod(method, value, (IJavaElement) viewerInput);

        }
    }

    private void setValueForMethod(IMethod method, Object value, IJavaElement javaElement) throws CoreException {
        ICompilationUnit source = AnnotationUtils.getCompilationUnitFromJavaElement(javaElement);
        CompilationUnit compilationUnit = SharedASTProvider.getAST(source, SharedASTProvider.WAIT_YES, null);
        AST ast = compilationUnit.getAST();

        for (Annotation annotation : annotations) {
            if (annotation instanceof NormalAnnotation) {
                NormalAnnotation normalAnnotation = (NormalAnnotation) annotation;
                IType declaringType = method.getDeclaringType();
                String annotationName = normalAnnotation.getTypeName().getFullyQualifiedName();
                if (annotationName.equals(declaringType.getElementName()) || annotationName.equals(declaringType.getFullyQualifiedName())) {
                    @SuppressWarnings("unchecked")
                    List<MemberValuePair> memberValuePairs = normalAnnotation.values();
                    boolean hasMemberValuePair = false;
                    for (MemberValuePair memberValuePair : memberValuePairs) {
                        if (memberValuePair.getName().getIdentifier().equals(method.getElementName())) {
                            ASTNode memberValue = getMemberValuePairValue(ast, method, value);
                            if (memberValue != null) {
                                change.addEdit(AnnotationUtils.createUpdateMemberValuePairTextEdit(memberValuePair, memberValue));

                }
            } else if (annotation instanceof SingleMemberAnnotation) {
                SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) annotation;
                IType declaringType = method.getDeclaringType();
                String annotationName = singleMemberAnnotation.getTypeName().getFullyQualifiedName();
                if (annotationName.equals(declaringType.getElementName()) || annotationName.equals(declaringType.getFullyQualifiedName())) {
                    MemberValuePair memberValuePair = getMemberValuePair(ast, method, value);
                    if (memberValuePair != null) {
                        change.addEdit(AnnotationUtils.createUpdateSingleMemberAnnotationTextEdit(singleMemberAnnotation, memberValuePair.getValue()));

        executeChange(new NullProgressMonitor(), change);
    }

    private MemberValuePair getMemberValuePair(AST ast, IMethod method, Object value) throws JavaModelException {
        String returnType = method.getReturnType();
        if (SignatureUtils.isString(returnType)) {
            return AnnotationsCore.createStringMemberValuePair(ast, method.getElementName(), (String) value);
        }
        if (SignatureUtils.isBoolean(returnType)) {
            return AnnotationsCore.createBooleanMemberValuePair(ast, method.getElementName(), (Boolean) value);
        }

        if (SignatureUtils.isPrimitive(returnType)) {
            if (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 AnnotationsCore.createNumberMemberValuePair(ast, method.getElementName(), value.toString());
            }
        }

        if (SignatureUtils.isArray(returnType)) {
            IType componentType = getComponentType(method);
            if (componentType != null) {
                if (componentType.isAnnotation()) {
                    return createArrayMemberValuePair(ast, method, (Object[]) value);
                } else {
                    return AnnotationsCore.createArrayMemberValuePair(ast, method.getElementName(), (Object[]) value);
                }
            } else {
                return AnnotationsCore.createArrayValueLiteral(ast, (Object[]) value);
            }
        }

        if (SignatureUtils.isClass(returnType)) {
            return AnnotationsCore.createTypeMemberValuePair(ast, method.getElementName(), value.toString());
        }

        IType enumType = SignatureUtils.getEnumReturnType(method);
        if (enumType != null) {
            int selected = ((Integer) value).intValue();
            if (selected != -1) {
                if (enumType.isMember()) {
                    return AnnotationsCore.createEnumMemberValuePair(ast, enumType.getDeclaringType().getFullyQualifiedName(),
                            method.getElementName(), SignatureUtils.getEnumConstants(enumType)[selected]);
                } else {
                    return AnnotationsCore.createEnumMemberValuePair(ast, enumType.getFullyQualifiedName(),
                            method.getElementName(), SignatureUtils.getEnumConstants(enumType)[selected]);
                }
            }
        }
        return null;
    }

    private ASTNode getMemberValuePairValue(AST ast, IMethod method, Object value) throws JavaModelException {
        String returnType = method.getReturnType();
        if (SignatureUtils.isString(returnType)) {
            return AnnotationsCore.createStringLiteral(ast, value.toString());
        }

        if (SignatureUtils.isBoolean(returnType)) {
            return AnnotationsCore.createBooleanLiteral(ast, ((Boolean) value).booleanValue());
        }

        if (SignatureUtils.isPrimitive(returnType)) {
            if (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 AnnotationsCore.createNumberLiteral(ast, value.toString());
            }
        }

        if (SignatureUtils.isArray(returnType)) {
            IType componentType = getComponentType(method);
            if (componentType != null) {
                if (componentType.isAnnotation()) {
                    return createArrayValueLiteral(ast, method, (Object[]) value);
                } else {
                    return AnnotationsCore.createArrayValueLiteral(ast, (Object[]) value);
                }
            }
        }

        if (SignatureUtils.isClass(returnType)) {
            return AnnotationsCore.createTypeLiteral(ast, value.toString());
        }


        IType enumType = SignatureUtils.getEnumReturnType(method);
        if (enumType != null) {
            int selected = ((Integer) value).intValue();
            if (selected != -1) {
                if (enumType.isMember()) {
                    return AnnotationsCore.createEnumLiteral(ast, enumType.getDeclaringType().getFullyQualifiedName(),
                            SignatureUtils.getEnumConstants(enumType)[selected]);
                } else {
                    return AnnotationsCore.createEnumLiteral(ast, enumType.getFullyQualifiedName(),
                            SignatureUtils.getEnumConstants(enumType)[selected]);
                }
            }
        }

        return null;
    }


        annotationsView.refreshLabels();
    }

    private MemberValuePair createArrayMemberValuePair(AST ast, IMethod method, Object[] values) throws JavaModelException {
        return AnnotationsCore.createMemberValuePair(ast, method.getElementName(), createArrayValueLiteral(ast,
                method, values));
    }

    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 ArrayInitializer createArrayValueLiteral(AST ast, IMethod method, Object[] values) throws JavaModelException {
        ArrayInitializer arrayInitializer = ast.newArrayInitializer();
        for (Object value : values) {
            if (value instanceof List<?>) {
                IType componentType = getComponentType(method);
                if (componentType != null) {

                    List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
                    @SuppressWarnings("unchecked")
                    List<Map<String, Object>> valuesList = (List<Map<String, Object>>) value;
                    Iterator<Map<String, Object>> valuesIterator = valuesList.iterator();
                    while (valuesIterator.hasNext()) {
                        Map<String, Object> annotationMap = valuesIterator.next();
                        Set<Entry<String, Object>> entrySet = annotationMap.entrySet();
                        Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();
                        while (iterator.hasNext()) {
                            Map.Entry<java.lang.String, Object> entry = iterator.next();
                            String memberName = entry.getKey();
                            try {
                                IMethod annotationMethod = componentType.getMethod(memberName, new String[] {});
                                if (annotationMethod != null) {
                                    Object memberValue = entry.getValue();
                                    String returnType = annotationMethod.getReturnType();
                                    if (SignatureUtils.isString(returnType)) {
                                        memberValuePairs.add(AnnotationsCore.createStringMemberValuePair(ast, memberName,
                                                memberValue.toString()));
                                }
                                if (returnType.equals(Boolean.TYPE)) {
                                    memberValuePairs.add(AnnotationsCore.createBooleanMemberValuePair(ast, memberName,
                                            (Boolean) memberValue));
                                }
                                if (returnType.equals(Class.class)) {
                                    String className = memberValue.toString();
                                    if (className.endsWith(".class")) {
                                        className = className.substring(0, className.lastIndexOf("."));
                                    }
                                    if (SignatureUtils.isBoolean(returnType)) {
                                        memberValuePairs.add(AnnotationsCore.createBooleanMemberValuePair(ast, memberName,
                                                (Boolean) memberValue));
                                    }
                                    if (SignatureUtils.isClass(returnType)) {
                                        String className = memberValue.toString();
                                        if (className.endsWith(".class")) {
                                            className = className.substring(0, className.lastIndexOf("."));
                                        }
                                        memberValuePairs.add(AnnotationsCore.createMemberValuePair(ast, memberName,
                                                AnnotationsCore.createTypeLiteral(ast, className)));
                                    }
                                    //                                if (returnType.isPrimitive()) {
                                    //                                    memberValuePairs.add(getNumberMemberValuePair(ast, memberName, memberValue));
                                    //                                }
                                }
                                //                                if (returnType.isPrimitive()) {
                                //                                    memberValuePairs.add(getNumberMemberValuePair(ast, memberName, memberValue));
                                //                                }
                            }

                            } catch (SecurityException se) {
                                AnnotationsCorePlugin.log(se);
                            }
                            AnnotationsCorePlugin.log(nsme);
                        }
                    }
                    arrayInitializer.expressions().add(AnnotationsCore.createNormalAnnotation(ast, componentType.getFullyQualifiedName(),
                            memberValuePairs));
                }
                arrayInitializer.expressions().add(AnnotationsCore.createNormalAnnotation(ast, annotationClass.getCanonicalName(),
                        memberValuePairs));
            }
        }
        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.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;


    @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());
            }

        IDialogSettings settings = JAXWSUIPlugin.getDefault().getDialogSettings();
        settings.put(TAG_CATEGORY_NAME, categories.toArray(new String[categories.size()]));
    }

}




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)",

Lines 11-24 Link Here

(-)src/org/eclipse/jst/ws/internal/jaxws/ui/annotations/initialization/BindingTypeAttributeInitializer.java (-4 / +5 lines)
11	package org.eclipse.jst.ws.internal.jaxws.ui.annotations.initialization;	11	package org.eclipse.jst.ws.internal.jaxws.ui.annotations.initialization;
12		12
13	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.VALUE;	13	import static org.eclipse.jst.ws.internal.jaxws.core.utils.JAXWSUtils.VALUE;
14	import java.lang.annotation.Annotation;	14
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16	import java.util.HashMap;	16	import java.util.HashMap;
17	import java.util.Iterator;	17	import java.util.Iterator;
18	import java.util.List;	18	import java.util.List;
19	import java.util.Map;	19	import java.util.Map;
		20
20	import javax.xml.ws.http.HTTPBinding;	21	import javax.xml.ws.http.HTTPBinding;
21	import javax.xml.ws.soap.SOAPBinding;	22	import javax.xml.ws.soap.SOAPBinding;
		23
22	import org.eclipse.jdt.core.IJavaElement;	24	import org.eclipse.jdt.core.IJavaElement;
23	import org.eclipse.jdt.core.IType;	25	import org.eclipse.jdt.core.IType;
24	import org.eclipse.jdt.core.dom.AST;	26	import org.eclipse.jdt.core.dom.AST;
Lines 49-58 Link Here
49	JAXWSUIPlugin.getDefault().getImageRegistry().put(HTTP_BINDING,	51	JAXWSUIPlugin.getDefault().getImageRegistry().put(HTTP_BINDING,
50	JAXWSUIPlugin.getImageDescriptor("icons/obj16/httpbinding_obj.gif").createImage()); //$NON-NLS-1$	52	JAXWSUIPlugin.getImageDescriptor("icons/obj16/httpbinding_obj.gif").createImage()); //$NON-NLS-1$
51	}	53	}
52		54
53	@Override	55	@Override
54	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast,	56	public List<MemberValuePair> getMemberValuePairs(IJavaElement javaElement, AST ast, IType annotationType) {
55	Class<? extends Annotation> annotationClass) {
56	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();	57	List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
57	if (javaElement.getElementType() == IJavaElement.TYPE) {	58	if (javaElement.getElementType() == IJavaElement.TYPE) {
58	MemberValuePair value = AnnotationsCore.createStringMemberValuePair(ast, VALUE, getDefault()); //$NON-NLS-1$	59	MemberValuePair value = AnnotationsCore.createStringMemberValuePair(ast, VALUE, getDefault()); //$NON-NLS-1$