org.eclipse.jst.ws.jaxws.core

https://bugs.eclipse.org/bugs/show_bug.cgi?id=260695
https://bugs.eclipse.org/bugs/show_bug.cgi?id=261696
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/.classpath b/bundles/org.eclipse.jst.ws.jaxws.core/.classpath
new file mode 100644
index 0000000..64c5e31
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/.project b/bundles/org.eclipse.jst.ws.jaxws.core/.project
new file mode 100644
index 0000000..379770e
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.ws.jaxws.core</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/.settings/org.eclipse.jdt.core.prefs b/bundles/org.eclipse.jst.ws.jaxws.core/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..83e002a
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+#Mon Feb 02 11:50:42 GMT 2009
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/META-INF/MANIFEST.MF b/bundles/org.eclipse.jst.ws.jaxws.core/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..40dce38
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/META-INF/MANIFEST.MF
@@ -0,0 +1,32 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.jst.ws.jaxws.core;singleton:=true
+Bundle-Vendor: %pluginProvider
+Bundle-Version: 0.5.0.qualifier
+Bundle-Localization: plugin
+Eclipse-BuddyPolicy: registered
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Import-Package: javax.jws,
+ javax.jws.soap,
+ javax.xml.ws,
+ javax.xml.ws.handler;version="2.1.0",
+ javax.xml.ws.handler.soap;version="2.1.0",
+ javax.xml.ws.http;version="2.1.0",
+ javax.xml.ws.soap;version="2.1.0",
+ javax.xml.ws.spi;version="2.1.0",
+ javax.xml.ws.wsaddressing;version="2.1.0"
+Bundle-Activator: org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.jdt.core,
+ org.eclipse.core.resources,
+ org.eclipse.core.filesystem,
+ org.eclipse.core.filebuffers,
+ org.eclipse.jdt.ui,
+ org.eclipse.jface.text,
+ org.eclipse.ltk.core.refactoring,
+ org.eclipse.jdt.apt.core
+Export-Package: org.eclipse.jst.ws.internal.jaxws.core,
+ org.eclipse.jst.ws.internal.jaxws.core.annotations,
+ org.eclipse.jst.ws.internal.jaxws.core.annotations.initialization,
+ org.eclipse.jst.ws.internal.jaxws.core.utils
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/about.html b/bundles/org.eclipse.jst.ws.jaxws.core/about.html
new file mode 100644
index 0000000..5b6a031
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>February 19, 2009</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/build.properties b/bundles/org.eclipse.jst.ws.jaxws.core/build.properties
new file mode 100644
index 0000000..921a77d
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/build.properties
@@ -0,0 +1,8 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               schema/,\
+               plugin.properties,\
+               about.html
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/plugin.properties b/bundles/org.eclipse.jst.ws.jaxws.core/plugin.properties
new file mode 100644
index 0000000..47f15c5
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/plugin.properties
@@ -0,0 +1,16 @@
+###############################################################################
+# Copyright (c) 2009 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
+###############################################################################
+
+#properties file for JAXWS Core
+pluginName=JAX-WS Tools Core (Incubation)
+providerName=Eclipse.org
+
+JAXWS_CATEGORY_NAME=JAX-WS
\ No newline at end of file
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/plugin.xml b/bundles/org.eclipse.jst.ws.jaxws.core/plugin.xml
new file mode 100644
index 0000000..12ea472
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/plugin.xml
@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.2"?>
+<plugin>
+   <extension-point id="annotationCategory" name="Annotation Category" schema="schema/annotationCategory.exsd"/>
+   <extension-point id="annotationDefinition" name="Annotation Definition" schema="schema/annotationDefinition.exsd"/>
+
+   <extension point="org.eclipse.jst.ws.jaxws.core.annotationCategory">
+      <category
+            id="jaxws.category"
+            name="%JAXWS_CATEGORY_NAME">
+      </category>
+   </extension>
+
+   <extension point="org.eclipse.jst.ws.jaxws.core.annotationDefinition">
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.WebService"
+            initializer="org.eclipse.jst.ws.internal.jaxws.core.annotations.initialization.WebServiceAttributeInitializer"
+            name="WebService">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.WebMethod"
+            initializer="org.eclipse.jst.ws.internal.jaxws.core.annotations.initialization.WebMethodAttributeInitializer"
+            name="WebMethod">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.WebParam"
+            initializer="org.eclipse.jst.ws.internal.jaxws.core.annotations.initialization.WebParamAttributeInitializer"
+            name="WebParam">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.WebResult"
+            name="WebResult">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.HandlerChain"
+            name="HandlerChain">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.Oneway"
+            name="Oneway">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.soap.SOAPMessageHandler"
+            name="SOAPMessageHandler">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.soap.SOAPMessageHandlers"
+            name="SOAPMessageHandlers">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.jws.soap.SOAPBinding"
+            name="SOAPBinding">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.WebServiceProvider"
+            name="WebServiceProvider"
+            restrictedTo="CLASS_ONLY">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.WebServiceClient"
+            name="WebServiceClient"
+            restrictedTo="CLASS_ONLY">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.WebServiceRef"
+            name="WebServiceRef">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.WebServiceRefs"
+            name="WebServiceRefs">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.ServiceMode"
+            name="ServiceMode">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.WebFault"
+            name="WebFault">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.RespectBinding"
+            name="RespectBinding"
+            restrictedTo="CLASS_ONLY">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.BindingType"
+            name="BindingType"
+            restrictedTo="CLASS_ONLY">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.soap.Addressing"
+            name="Addressing">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.soap.MTOM"
+            name="MTOM">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.FaultAction"
+            name="FaultAction">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.RequestWrapper"
+            initializer="org.eclipse.jst.ws.internal.jaxws.core.annotations.initialization.RequestWrapperAttributeInitializer"
+            name="RequestWrapper">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.ResponseWrapper"
+            initializer="org.eclipse.jst.ws.internal.jaxws.core.annotations.initialization.ResponseWrapperAttributeInitializer"
+            name="ResponseWrapper">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.WebEndpoint"
+            name="WebEndpoint"
+            restrictedTo="CLASS_ONLY">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.Action"
+            name="Action">
+      </annotation>
+      <annotation
+            category="jaxws.category"
+            class="javax.xml.ws.spi.WebServiceFeatureAnnotation"
+            name="WebServiceFeatureAnnotation">
+      </annotation>
+   </extension>
+
+</plugin>
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/schema/annotationCategory.exsd b/bundles/org.eclipse.jst.ws.jaxws.core/schema/annotationCategory.exsd
new file mode 100644
index 0000000..e71ebe4
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/schema/annotationCategory.exsd
@@ -0,0 +1,123 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- Schema file written by PDE -->
+<schema targetNamespace="org.eclipse.jst.ws.jaxws.core" xmlns="http://www.w3.org/2001/XMLSchema">
+<annotation>
+      <appinfo>
+         <meta.schema plugin="org.eclipse.jst.ws.jaxws.core" id="annotationCategory" name="Annotation Category"/>
+      </appinfo>
+      <documentation>
+         [Enter description of this extension point.]
+      </documentation>
+   </annotation>
+
+   <element name="extension">
+      <annotation>
+         <appinfo>
+            <meta.element />
+         </appinfo>
+      </annotation>
+      <complexType>
+         <sequence minOccurs="1" maxOccurs="unbounded">
+            <element ref="category" minOccurs="0" maxOccurs="unbounded"/>
+         </sequence>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="category">
+      <annotation>
+         <documentation>
+            An annotation category contribution defines categories of annotations used to group them in the UI.
+         </documentation>
+      </annotation>
+      <complexType>
+         <attribute name="id" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="since"/>
+      </appinfo>
+      <documentation>
+         [Enter the first release in which this extension point appears.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="examples"/>
+      </appinfo>
+      <documentation>
+         [Enter extension point usage example here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="apiinfo"/>
+      </appinfo>
+      <documentation>
+         [Enter API information here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="implementation"/>
+      </appinfo>
+      <documentation>
+         [Enter information about supplied implementation of this extension point.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="copyright"/>
+      </appinfo>
+      <documentation>
+         Copyright (c) 2009 Shane Clarke. &lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
+      </documentation>
+   </annotation>
+
+</schema>
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/schema/annotationDefinition.exsd b/bundles/org.eclipse.jst.ws.jaxws.core/schema/annotationDefinition.exsd
new file mode 100644
index 0000000..6649950
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/schema/annotationDefinition.exsd
@@ -0,0 +1,158 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- Schema file written by PDE -->
+<schema targetNamespace="org.eclipse.jst.ws.jaxws.core" xmlns="http://www.w3.org/2001/XMLSchema">
+<annotation>
+      <appinfo>
+         <meta.schema plugin="org.eclipse.jst.ws.jaxws.core" id="annotationDefinition" name="Annotation Definition"/>
+      </appinfo>
+      <documentation>
+         This extension point allows clients to contribute annotations &lt;? extends java.lang.annotation.Annotation&gt; which are in turn consumed by the UI.
+      </documentation>
+   </annotation>
+
+   <element name="extension">
+      <annotation>
+         <appinfo>
+            <meta.element />
+         </appinfo>
+      </annotation>
+      <complexType>
+         <sequence minOccurs="0" maxOccurs="unbounded">
+            <element ref="annotation" minOccurs="0" maxOccurs="unbounded"/>
+         </sequence>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="annotation">
+      <complexType>
+         <attribute name="class" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="java" basedOn="java.lang.annotation.Annotation:"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="category" type="string" use="required">
+            <annotation>
+               <documentation>
+                  the id of a &lt;tt&gt;annotationCategory&lt;/tt&gt;
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="identifier" basedOn="org.eclipse.jst.ws.jaxws.core.annotationCategory/category/@id"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="initializer" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="java" basedOn=":org.eclipse.jst.ws.internal.jaxws.core.annotations.IAnnotationAttributeInitializer"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="restrictedTo">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+            <simpleType>
+               <restriction base="string">
+                  <enumeration value="CLASS_ONLY">
+                  </enumeration>
+                  <enumeration value="INTERFACE_ONLY">
+                  </enumeration>
+                  <enumeration value="ENUM_ONLY">
+                  </enumeration>
+               </restriction>
+            </simpleType>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="since"/>
+      </appinfo>
+      <documentation>
+         0.7.0
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="examples"/>
+      </appinfo>
+      <documentation>
+         [Enter extension point usage example here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="apiinfo"/>
+      </appinfo>
+      <documentation>
+         [Enter API information here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="implementation"/>
+      </appinfo>
+      <documentation>
+         [Enter information about supplied implementation of this extension point.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="copyright"/>
+      </appinfo>
+      <documentation>
+         Copyright (c) 2009 Shane Clarke. &lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
+      </documentation>
+   </annotation>
+
+</schema>
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCoreMessages.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCoreMessages.java
new file mode 100644
index 0000000..a74afdb
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCoreMessages.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core;
+
+import org.eclipse.osgi.util.NLS;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class JAXWSCoreMessages extends NLS {
+    private static final String BUNDLE_NAME = 
+        "org.eclipse.jst.ws.internal.jaxws.core.JAXWSCoreMessages"; //$NON-NLS-1$
+
+    public static String TYPE_NAME_DIFFERENT_CASE_EXISTS;
+    public static String TYPE_WITH_NAME_ALREADY_EXISTS;
+    
+    static {
+        // initialize resource bundle
+        NLS.initializeMessages(BUNDLE_NAME, JAXWSCoreMessages.class);
+    }
+
+    private JAXWSCoreMessages() {
+    }
+
+
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCoreMessages.properties b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCoreMessages.properties
new file mode 100644
index 0000000..a466fbc
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCoreMessages.properties
@@ -0,0 +1,16 @@
+###############################################################################
+# Copyright (c) 2008 IONA Technologies PLC
+# 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:
+# IONA Technologies PLC - initial API and implementation
+###############################################################################
+
+#JDTUtils
+TYPE_NAME_DIFFERENT_CASE_EXISTS=A Type with the same name but different case already exists
+TYPE_WITH_NAME_ALREADY_EXISTS=A compilation unit named ''{0}'' already exists in package ''{1}''
+CXF_FACET_INSTALL_DELEGATE_RUNTIME_LOCATION_NOT_SET=CXF Runtime location not set. Please set location in Preferences > Web Services > CXf 2.x Preferences
+CXF_CONTAINER_LIBRARY={0} Library [{1}]
\ No newline at end of file
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCorePlugin.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCorePlugin.java
new file mode 100644
index 0000000..d42e1d2
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/JAXWSCorePlugin.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Plugin;
+import org.eclipse.core.runtime.Status;
+import org.osgi.framework.BundleContext;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class JAXWSCorePlugin extends Plugin {
+    public static final String PLUGIN_ID = "org.eclipse.jst.ws.jaxws.core"; //$NON-NLS-1$
+    
+    // The shared instance
+    private static JAXWSCorePlugin plugin;
+    
+    public static JAXWSCorePlugin getDefault() {
+      return plugin;
+    }
+    
+    public void start(BundleContext context) throws Exception {
+        super.start(context);
+        plugin = this;
+    }
+
+    public void stop(BundleContext context) throws Exception {
+        plugin = null;
+        super.stop(context);
+    }
+    
+    public static void logMessage(int severity, String message) {
+        JAXWSCorePlugin.log(new Status(severity, JAXWSCorePlugin.PLUGIN_ID, message));
+    }
+
+    public static void log(IStatus status) {
+        JAXWSCorePlugin.getDefault().getLog().log(status);
+    }
+
+    public static void log(Throwable exception) {
+        JAXWSCorePlugin.log(new Status(IStatus.ERROR, JAXWSCorePlugin.PLUGIN_ID, exception
+                .getLocalizedMessage(), exception));
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationAttributeInitializerAdapter.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationAttributeInitializerAdapter.java
new file mode 100644
index 0000000..979b303
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationAttributeInitializerAdapter.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class AnnotationAttributeInitializerAdapter implements IAnnotationAttributeInitializer {
+
+    public AnnotationAttributeInitializerAdapter() {    
+    }
+    
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return getMemberValuePairs(ast, annotationClass);
+    }
+
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return getMemberValuePairs(ast, annotationClass);
+    }
+    
+    private List<MemberValuePair> getMemberValuePairs(AST ast,
+            Class<? extends Annotation> annotationClass) {
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+        
+        Method[] declaredMethods = annotationClass.getDeclaredMethods();
+        for (Method method : declaredMethods) {
+            String name = method.getName();
+            Class<?> returnType = method.getReturnType();
+            Object defaultValue = method.getDefaultValue();
+
+            if (defaultValue != null) {
+                if (returnType.equals(String.class)) {
+                    memberValuePairs.add(AnnotationsCore.getStringMemberValuePair(ast,
+                            name, defaultValue.toString()));
+                }
+                
+                if (returnType.equals(Boolean.TYPE)) {
+                    memberValuePairs.add(AnnotationsCore.getBooleanMemberValuePair(ast,
+                            name, Boolean.parseBoolean(defaultValue.toString())));
+                }
+                
+                if (returnType.isPrimitive() && (returnType.equals(Byte.TYPE) || returnType.equals(Short.TYPE) 
+                        || returnType.equals(Integer.TYPE) || returnType.equals(Long.TYPE)
+                        || returnType.equals(Float.TYPE) || returnType.equals(Double.TYPE))) {
+                    memberValuePairs.add(AnnotationsCore.getNumberMemberValuePair(ast, name, defaultValue));
+                }
+                
+                if (returnType.isArray()) {
+                    memberValuePairs.add(AnnotationsCore.getArrayMemberValuePair(ast, method, 
+                            (Object[])defaultValue));
+                }
+                
+                if (returnType.isEnum()) {
+                    memberValuePairs.add(AnnotationsCore.getEnumMemberValuePair(ast, 
+                            method.getDeclaringClass().getCanonicalName(), name, defaultValue));
+                }
+                
+                if (returnType.equals(Class.class)) {
+                    memberValuePairs.add(AnnotationsCore.getTypeMemberVaulePair(ast, name, 
+                            defaultValue));
+                }
+            }
+        }      
+        return memberValuePairs;
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationDefinition.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationDefinition.java
new file mode 100644
index 0000000..23e11b8
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationDefinition.java
@@ -0,0 +1,134 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class AnnotationDefinition {
+    
+    private final IConfigurationElement configurationElement;
+
+    private static final String ATT_CLASS = "class"; //$NON-NLS-1$
+    private static final String ATT_NAME = "name"; //$NON-NLS-1$
+    private static final String ATT_INITIALIZER = "initializer"; //$NON-NLS-1$
+    private static final String ATT_RESTRICTED_TO = "restrictedTo"; //$NON-NLS-1$
+    
+    private static final String RESTRICTED_TO_CLASS_ONLY = "CLASS_ONLY";
+    private static final String RESTRICTED_TO_INTERFACE_ONLY = "INTERFACE_ONLY";
+    private static final String RESTRICTED_TO_ENUM_ONLY = "ENUM_ONLY";
+    
+    private String category;
+    private String annotationClassName;
+    private Class<? extends java.lang.annotation.Annotation> annotationClass;
+    private List<ElementType> targets;
+    private String name;
+    private String annotationInitializerClassName;
+    private IAnnotationAttributeInitializer annotationInitializer;
+    private String restictedTo;
+    private boolean interfaceOnly;
+    private boolean classOnly;
+    private boolean enumOnly;
+    
+    public AnnotationDefinition(IConfigurationElement configurationElement, String category) {
+        this.configurationElement = configurationElement;
+        this.category = category;
+        this.annotationClassName = AnnotationsManager.getAttributeValue(configurationElement, ATT_CLASS);
+        this.name = AnnotationsManager.getAttributeValue(configurationElement, ATT_NAME);
+        this.annotationInitializerClassName = AnnotationsManager.getAttributeValue(configurationElement, 
+                ATT_INITIALIZER);
+        this.restictedTo = AnnotationsManager.getAttributeValue(configurationElement, 
+                ATT_RESTRICTED_TO);
+        this.classOnly = restictedTo.equals(RESTRICTED_TO_CLASS_ONLY);
+        this.interfaceOnly = restictedTo.equals(RESTRICTED_TO_INTERFACE_ONLY);
+        this.enumOnly = restictedTo.equals(RESTRICTED_TO_ENUM_ONLY);
+    }
+        
+    public String getName() {
+        return name;
+    }
+    
+    public String getCategory() {
+        return category;
+    }
+    
+    public String getAnnotationClassName() {
+        return annotationClassName;
+    }
+    
+    public boolean isClassOnly() {
+        return classOnly;
+    }
+    
+    public boolean isInterfaceOnly() {
+        return interfaceOnly;
+    }
+    
+    public boolean isEnumOnly() {
+        return enumOnly;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public Class<? extends java.lang.annotation.Annotation> getAnnotationClass() {
+        if (annotationClass == null) {
+            try {
+                Class<?> aClass = Class.forName(annotationClassName);
+                if (aClass.isAnnotation()) {
+                    annotationClass = (Class<java.lang.annotation.Annotation>)Class.forName(annotationClassName);
+                }
+            } catch(ClassNotFoundException cnfe) {
+                JAXWSCorePlugin.log(cnfe);
+            }
+        }
+        return annotationClass;
+    }
+    
+    public List<ElementType> getTargets() {
+        if (targets == null) {
+            Class<? extends java.lang.annotation.Annotation> annotation = getAnnotationClass();
+            Target target = annotation.getAnnotation(Target.class);
+            if (target != null) {
+                targets = Arrays.asList(target.value());
+            } else {
+                targets = Collections.emptyList();
+            }
+        }
+        return targets;
+    }
+    
+    public IAnnotationAttributeInitializer getAnnotationAttributeInitializer() {
+        if (annotationInitializer == null) {
+            try {
+                if (annotationInitializerClassName != null && annotationInitializerClassName.length() > 0) {
+                    annotationInitializer = (IAnnotationAttributeInitializer)configurationElement.
+                        createExecutableExtension(ATT_INITIALIZER);
+                } else {
+                    annotationInitializer = new AnnotationAttributeInitializerAdapter();
+                }
+            } catch (CoreException ce) {
+                JAXWSCorePlugin.log(ce.getStatus());
+            }
+        }
+        return annotationInitializer;
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationsCore.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationsCore.java
new file mode 100644
index 0000000..caaa97f
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationsCore.java
@@ -0,0 +1,312 @@
+/*******************************************************************************
+ * Copyright (c) 2008 IONA Technologies PLC
+ * 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:
+ * IONA Technologies PLC - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.ws.internal.jaxws.core.annotations;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.Annotation;
+import org.eclipse.jdt.core.dom.ArrayInitializer;
+import org.eclipse.jdt.core.dom.BooleanLiteral;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jdt.core.dom.Name;
+import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jdt.core.dom.NumberLiteral;
+import org.eclipse.jdt.core.dom.QualifiedName;
+import org.eclipse.jdt.core.dom.QualifiedType;
+import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.core.dom.StringLiteral;
+import org.eclipse.jdt.core.dom.TypeLiteral;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+/**
+ * 
+ * @author sclarke
+ */
+public final class AnnotationsCore {
+
+    private AnnotationsCore() {
+    }
+    
+    public static MemberValuePair createMemberValuePair(AST ast, String name, Expression expression) {
+        MemberValuePair memberValuePair = ast.newMemberValuePair();
+        memberValuePair.setName(ast.newSimpleName(name));
+        memberValuePair.setValue(expression);
+        return memberValuePair;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static Annotation getAnnotation(AST ast,
+            Class<? extends java.lang.annotation.Annotation> annotationClass,
+            List<MemberValuePair> memberValuePairs) {
+
+        NormalAnnotation annotation = ast.newNormalAnnotation();
+        Name annotationTypeName = ast.newName(annotationClass.getSimpleName());
+        //Name annotationTypeName = ast.newName(annotationClass.getCanonicalName());
+        annotation.setTypeName(annotationTypeName);
+
+        if (memberValuePairs != null) {
+            for (MemberValuePair memberValuePair : memberValuePairs) {
+                List<MemberValuePair> annotationValues = annotation.values();
+                annotationValues.add(memberValuePair);
+            }
+        }
+        return annotation;
+    }
+
+    public static MemberValuePair getNameValuePair(AST ast, String name) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "name", name); //$NON-NLS-1$
+    }
+
+    public static MemberValuePair getEndpointInterfaceValuePair(AST ast, String endpointInterface) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "endpointInterface", //$NON-NLS-1$
+                endpointInterface);
+    }
+
+//    public static MemberValuePair getTargetNamespaceValuePair(AST ast, String targetNamespace) {
+//        return AnnotationsCore.getStringMemberValuePair(ast, "targetNamespace", targetNamespace); //$NON-NLS-1$
+//    }
+
+    public static MemberValuePair getPortNameValuePair(AST ast, String portName) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "portName", portName); //$NON-NLS-1$
+    }
+
+    public static MemberValuePair getServiceNameValuePair(AST ast, String serviceName) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "serviceName", serviceName); //$NON-NLS-1$
+    }
+
+//    public static MemberValuePair getOperationNameValuePair(AST ast, String operationName) {
+//        return AnnotationsCore.getStringMemberValuePair(ast, "operationName", operationName); //$NON-NLS-1$
+//    }
+
+    public static MemberValuePair getExcludeValuePair(AST ast, boolean exclude) {
+        return AnnotationsCore.getBooleanMemberValuePair(ast, "exclude", exclude); //$NON-NLS-1$
+    }
+
+    public static MemberValuePair getPartNameValuePair(AST ast, String partName) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "partName", partName); //$NON-NLS-1$
+    }
+
+//    public static MemberValuePair getClassNameValuePair(AST ast, String className) {
+//        return AnnotationsCore.getStringMemberValuePair(ast, "className", className); //$NON-NLS-1$
+//    }
+
+//    public static MemberValuePair getLocalNameValuePair(AST ast, String localName) {
+//        return AnnotationsCore.getStringMemberValuePair(ast, "localName", localName); //$NON-NLS-1$
+//    }
+
+    public static MemberValuePair getFaultBeanValuePair(AST ast, String faultBean) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "faultBean", faultBean); //$NON-NLS-1$
+    }
+
+    public static MemberValuePair getWSDLLocationValuePair(AST ast, String wsdlLocation) {
+        return AnnotationsCore.getStringMemberValuePair(ast, "wsdlLocation", wsdlLocation); //$NON-NLS-1$
+    }
+
+    public static MemberValuePair getStringMemberValuePair(AST ast, String name, Object value) {
+        MemberValuePair stringMemberValuePair = AnnotationsCore.createMemberValuePair(ast, name,
+                AnnotationsCore.getStringLiteral(ast, value.toString()));
+
+        return stringMemberValuePair;
+    }
+
+    public static MemberValuePair getBooleanMemberValuePair(AST ast, String name, Object value) {
+        MemberValuePair booleanValuePair = AnnotationsCore.createMemberValuePair(ast, name, AnnotationsCore
+                .getBooleanLiteral(ast, ((Boolean)value).booleanValue()));
+
+        return booleanValuePair;
+    }
+    
+    public static MemberValuePair getNumberMemberValuePair(AST ast, String name, Object value) {
+        MemberValuePair primitiveValuePair = AnnotationsCore.createMemberValuePair(ast, name, 
+                AnnotationsCore.getNumberLiteral(ast, value.toString()));
+        return primitiveValuePair;
+    }
+    
+    public static MemberValuePair getEnumMemberValuePair(AST ast, String className, String name, Object value) {
+         return AnnotationsCore.createMemberValuePair(ast, name, getEnumLiteral(ast, className, value));        
+    }
+    
+    public static MemberValuePair getTypeMemberVaulePair(AST ast, String name, Object value) {
+        return AnnotationsCore.createMemberValuePair(ast, name,
+                getTypeLiteral(ast, value));
+    }
+    
+    public static MemberValuePair getArrayMemberValuePair(AST ast, Method method, Object[] values) {
+        return AnnotationsCore.createMemberValuePair(ast, method.getName(), getArrayValueLiteral(ast, method, values));
+     }
+    
+    @SuppressWarnings("unchecked")
+    public static ArrayInitializer getArrayValueLiteral(AST ast, Method method, Object[] values) {
+        ArrayInitializer arrayInitializer = getArrayInitializer(ast);
+        for (Object value : values) {
+            if (value instanceof java.lang.annotation.Annotation) {
+                //TODO Handle this situation. Arises when annotations are specified as defaults in array initializers
+            }
+            if (value instanceof List) {
+                Class<? extends java.lang.annotation.Annotation> annotationClass = 
+                    (Class<? extends java.lang.annotation.Annotation>) method.getReturnType().getComponentType();
+
+                List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+
+                List<Map<String, Object>> valuesList = (List<Map<String, Object>>) value;
+                Iterator<Map<String, Object>> valuesIterator = valuesList.iterator();
+                while (valuesIterator.hasNext()) {
+                    Map<String, Object> annotationMap = (Map<String, Object>) 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 {
+                            Method annotationMethod = annotationClass.getMethod(memberName, null);
+                            if (annotationMethod != null) {
+                                Object memberValue = entry.getValue();
+                                Class<?> returnType = annotationMethod.getReturnType();
+                                if (returnType.equals(String.class)) {
+                                    memberValuePairs.add(getStringMemberValuePair(ast, memberName, memberValue));
+                                }
+                                if (returnType.equals(Boolean.TYPE)) {
+                                    memberValuePairs.add(getBooleanMemberValuePair(ast, memberName, memberValue));                                    
+                                }
+                                if (returnType.equals(Class.class)) {
+                                    String className = memberValue.toString();
+                                    if (className.endsWith(".class")) {
+                                        className = className.substring(0, className.lastIndexOf("."));
+                                    }
+                                    memberValuePairs.add(AnnotationsCore.createMemberValuePair(ast, memberName,
+                                            getTypeLiteral(ast, className)));                                    
+                                }
+//                                if (returnType.isPrimitive()) {
+//                                    memberValuePairs.add(getNumberMemberValuePair(ast, memberName, memberValue));
+//                                }
+                            }
+                            
+                        } catch (SecurityException se) {
+                            JAXWSCorePlugin.log(se);
+                        } catch (NoSuchMethodException nsme) {
+                            JAXWSCorePlugin.log(nsme);
+                        }
+                    }
+                }
+                arrayInitializer.expressions().add(getAnnotation(ast, annotationClass, memberValuePairs));
+            }
+            if (value.equals(Class.class)) {
+                arrayInitializer.expressions().add(getTypeLiteral(ast, value.toString()));
+            }
+            if (value instanceof String) {
+                String stringValue = value.toString();
+                if (stringValue.endsWith(".class")) {
+                    arrayInitializer.expressions().add(getTypeLiteral(ast, stringValue.substring(0,
+                            stringValue.lastIndexOf("."))));
+                } else {
+                    arrayInitializer.expressions().add(getStringLiteral(ast, stringValue));
+                }
+            }
+        }
+        return arrayInitializer;
+    }
+    
+    public static Name getEnumLiteral(AST ast, String className, Object value) {
+        QualifiedName enumName = null;
+        SimpleName enumClassName = ast.newSimpleName(value.getClass().getSimpleName());
+        SimpleName enumLiteral = ast.newSimpleName(value.toString());
+        if (value.getClass().isMemberClass()) {
+            Name enumEnclosingClassName = null;
+            String enclosingClassName = value.getClass().getEnclosingClass().getCanonicalName();
+            if (enclosingClassName.equals(className)) {
+                enumEnclosingClassName = ast.newSimpleName(value.getClass().getEnclosingClass()
+                        .getSimpleName());
+            } else {
+                enumEnclosingClassName = ast.newName(enclosingClassName);
+            }
+            QualifiedName qualifiedName = ast.newQualifiedName(enumEnclosingClassName, enumClassName);
+            enumName = ast.newQualifiedName(qualifiedName, enumLiteral);
+        } else {
+            Name qualifiedName = ast.newName(value.getClass().getCanonicalName());
+            enumName = ast.newQualifiedName(qualifiedName, enumLiteral);
+        }
+        return enumName;
+    }
+
+    public static TypeLiteral getTypeLiteral(AST ast, Object value) {
+        TypeLiteral typeLiteral = null;
+        if (value instanceof Class) {
+            typeLiteral = getTypeLiteral(ast, (Class<?>) value);
+        }
+        if (value instanceof String) {
+            typeLiteral = getTypeLiteral(ast, (String) value);
+        }
+        return typeLiteral;
+    }
+
+    public static TypeLiteral getTypeLiteral(AST ast, Class<?> value) {
+        TypeLiteral typeLiteral = ast.newTypeLiteral();
+
+        Class<?> aClass = (Class<?>)value;
+        SimpleName className = ast.newSimpleName(aClass.getSimpleName());
+
+        if (aClass.isMemberClass()) {
+            Name enclosingClassName = ast.newName(aClass.getEnclosingClass().getCanonicalName());
+            QualifiedType qualifiedType = ast.newQualifiedType(ast.newSimpleType(enclosingClassName), className);
+            typeLiteral.setType(qualifiedType);
+            return typeLiteral;
+        }
+        return getTypeLiteral(ast, value.getCanonicalName());
+    }
+
+    public static TypeLiteral getTypeLiteral(AST ast, String value) {
+        TypeLiteral typeLiteral = ast.newTypeLiteral();
+
+        if (value.toString().indexOf(".") == -1) { //$NON-NLS-1$
+            typeLiteral.setType(ast.newSimpleType(ast.newSimpleName(value.toString())));
+        } else {
+            String qualifier = value.toString().substring(0, value.toString().lastIndexOf(".")); //$NON-NLS-1$
+            String identifier = value.toString().substring(value.toString().lastIndexOf(".") + 1); //$NON-NLS-1$
+            if (qualifier.equals("java.lang")) { //$NON-NLS-1$
+                typeLiteral.setType(ast.newSimpleType(ast.newSimpleName(identifier)));
+            } else {
+                typeLiteral.setType(ast.newQualifiedType(ast.newSimpleType(ast.newName(qualifier)), ast
+                        .newSimpleName(identifier)));
+            }
+        }
+        return typeLiteral;
+    }
+
+    public static StringLiteral getStringLiteral(AST ast, String literalValue) {
+        StringLiteral stringLiteral = ast.newStringLiteral();
+        stringLiteral.setLiteralValue(literalValue);
+        return stringLiteral;
+    }
+
+    public static BooleanLiteral getBooleanLiteral(AST ast, boolean value) {
+        BooleanLiteral booleanLiteral = ast.newBooleanLiteral(value);
+        return booleanLiteral;
+    }
+    
+    public static NumberLiteral getNumberLiteral(AST ast, String value) {
+        NumberLiteral primitiveLiteral = ast.newNumberLiteral();
+        primitiveLiteral.setToken(value);
+        return primitiveLiteral;
+    }
+
+    public static ArrayInitializer getArrayInitializer(AST ast) {
+        ArrayInitializer arrayInitializer = ast.newArrayInitializer();
+        return arrayInitializer;
+    }
+    
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationsManager.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationsManager.java
new file mode 100644
index 0000000..84abf6a
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/AnnotationsManager.java
@@ -0,0 +1,323 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations;
+
+import java.lang.annotation.ElementType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.jdt.core.IAnnotation;
+import org.eclipse.jdt.core.IField;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.ILocalVariable;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IPackageDeclaration;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public final class AnnotationsManager {
+    public static final String ANNOTATION_DEFINITION = "annotationDefinition"; //$NON-NLS-1$
+    public static final String ANNOTATION_CATEGORY = "annotationCategory"; //$NON-NLS-1$
+    public static final String ANNOTATION = "ANNOTATION"; //$NON-NLS-1$
+
+    private static Map<String, String> annotationCategoryCache = null;
+    private static Map<String, List<AnnotationDefinition>> annotationsByCategoryMap = null;
+    private static List<AnnotationDefinition> annotationCache = null;
+    private static Map<Class<? extends java.lang.annotation.Annotation>, AnnotationDefinition> 
+            annotationClassToDefinitionMap;
+
+    private static final String ATT_ID = "id"; //$NON-NLS-1$
+    private static final String ATT_NAME = "name"; //$NON-NLS-1$
+    private static final String ATT_CATEGORY = "category"; //$NON-NLS-1$
+
+    private AnnotationsManager() {
+    }
+    
+    public static Object[] getAnnotations(Object element) {
+        List<Class<? extends java.lang.annotation.Annotation>> annotations = 
+            new ArrayList<Class<? extends java.lang.annotation.Annotation>>();
+        
+        try {
+            List<AnnotationDefinition> annotationDefinitions = getAllAnnotationsForElement(element);
+        
+            filterAnnotationsList(element, annotationDefinitions);
+        
+            for (AnnotationDefinition annotationDefinition : annotationDefinitions) {
+                annotations.add(annotationDefinition.getAnnotationClass());
+                getAnnotationToClassDefinitionMap().put(annotationDefinition.getAnnotationClass(),
+                        annotationDefinition);
+            }
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }  
+        return annotations.toArray();     
+    }
+    
+    private static synchronized Map<Class<? extends java.lang.annotation.Annotation>, AnnotationDefinition> 
+            getAnnotationToClassDefinitionMap() {
+        if (annotationClassToDefinitionMap == null) {
+            annotationClassToDefinitionMap = new HashMap<Class<? extends java.lang.annotation.Annotation>, 
+                AnnotationDefinition>();
+        }
+        return annotationClassToDefinitionMap;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static AnnotationDefinition getAnnotationDefinitionForClass(Object element) {
+        if (element instanceof Class && ((Class<?>)element).isAnnotation()) {
+            return getAnnotationToClassDefinitionMap().get(
+                (Class<? extends java.lang.annotation.Annotation>)element);
+        }
+        return null;
+    }
+    
+    public static AnnotationDefinition getAnnotationDefinitionForClass(Class<? 
+            extends java.lang.annotation.Annotation> annotationClass) {
+        return getAnnotationToClassDefinitionMap().get(annotationClass);
+    }
+    
+    public static synchronized List<AnnotationDefinition> getAnnotationsByCategory(String categoryName) {
+        if (annotationsByCategoryMap == null) {
+            annotationsByCategoryMap = new HashMap<String, List<AnnotationDefinition>>();
+            for (AnnotationDefinition annotationDefinition : getAnnotations()) {
+                if (annotationsByCategoryMap.get(annotationDefinition.getCategory()) == null) {
+                    List<AnnotationDefinition> annotationDefinitionList = new ArrayList<AnnotationDefinition>();
+                    annotationDefinitionList.add(annotationDefinition);
+                    annotationsByCategoryMap.put(annotationDefinition.getCategory(), annotationDefinitionList);
+                    continue;
+                }
+                annotationsByCategoryMap.get(annotationDefinition.getCategory()).add(annotationDefinition);
+            }
+        }
+        return annotationsByCategoryMap.get(categoryName);
+    }
+
+    public static List<String> getAnnotationCategories() {
+        return Arrays.asList(getAnnotationCategoryCache().values().toArray(
+                new String[getAnnotationCategoryCache().size()]));
+    }
+
+    public static String getAnnotationCategory(String categoryId) {
+        return getAnnotationCategoryCache().get(categoryId);        
+    }
+
+    private static synchronized Map<String, String> getAnnotationCategoryCache() {
+        if (annotationCategoryCache != null) {
+            return annotationCategoryCache;
+        }
+
+        annotationCategoryCache = new HashMap<String, String>();
+        
+        IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(
+                JAXWSCorePlugin.PLUGIN_ID, ANNOTATION_CATEGORY);
+        if (extensionPoint != null) {
+            IConfigurationElement[] elements = extensionPoint.getConfigurationElements();
+            for (int i = 0; i < elements.length; i++) {
+                IConfigurationElement element = elements[i];
+                annotationCategoryCache.put(getAttributeValue(element, ATT_ID), 
+                        getAttributeValue(element, ATT_NAME));
+            }
+        }
+        return annotationCategoryCache;
+    }
+    
+    public static String getAttributeValue(IConfigurationElement configurationElement, String attributeName) {
+        String attribute = configurationElement.getAttribute(attributeName);
+        if (attribute != null) {
+            return attribute;
+        }
+        return ""; //$NON-NLS-1$
+    }
+
+    private static List<AnnotationDefinition> getAllAnnotationsForElement(Object element) 
+            throws JavaModelException {
+        
+        if (element instanceof IPackageDeclaration) {
+            return getAnnotationsForElementType(ElementType.PACKAGE);
+        }
+        
+        if (element instanceof IType) {
+            IType type = (IType) element;
+            if (type.isAnnotation()) {
+                return getAnnotationsForElementType(ElementType.ANNOTATION_TYPE);
+            }
+            return getAnnotationsForElementType(ElementType.TYPE);
+        }
+        
+        if (element instanceof IField) {
+            return getAnnotationsForElementType(ElementType.FIELD);
+        }
+        
+        if (element instanceof IMethod) {
+            return getAnnotationsForElementType(ElementType.METHOD);
+        }
+        
+        if (element instanceof SingleVariableDeclaration) {
+            return getAnnotationsForElementType(ElementType.PARAMETER);
+        }
+        
+        if (element instanceof ILocalVariable) {
+            return getAnnotationsForElementType(ElementType.LOCAL_VARIABLE);
+        }
+        
+        if (element instanceof IAnnotation) {
+            return getAnnotationsForElementType(ElementType.ANNOTATION_TYPE);
+        }
+        
+        return Collections.emptyList();
+    }
+    
+    private static List<AnnotationDefinition> getAnnotationsForElementType(ElementType elementType) {
+        List<AnnotationDefinition> annotationDefinitions = new ArrayList<AnnotationDefinition>();
+        
+        if (annotationCache == null) {
+            annotationCache = getAnnotations();
+        }
+        
+        for (AnnotationDefinition annotationDefinition : annotationCache) {
+            if (annotationDefinition.getTargets().contains(elementType) && 
+                    !isDeprecated(annotationDefinition)) {
+                annotationDefinitions.add(annotationDefinition);
+            }
+        }
+        return annotationDefinitions;
+    }
+    
+    public static synchronized List<AnnotationDefinition> getAnnotations() {
+        if (annotationCache == null) {
+            annotationCache = new ArrayList<AnnotationDefinition>();
+            
+            IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(
+                    JAXWSCorePlugin.PLUGIN_ID, ANNOTATION_DEFINITION);
+            if (extensionPoint != null) {
+                IConfigurationElement[] elements = extensionPoint.getConfigurationElements();
+                for (int i = 0; i < elements.length; i++) {
+                    IConfigurationElement element = elements[i];
+                    if (element.getName().equalsIgnoreCase(ANNOTATION)) {
+                        annotationCache.add(new AnnotationDefinition(element, 
+                                getAnnotationCategory(getAttributeValue(element, ATT_CATEGORY))));
+                    }
+                }
+            }
+        }
+        return annotationCache;
+    }
+    
+    private static void filterAnnotationsList(Object element, 
+        List<AnnotationDefinition> annotationDefinitions) throws JavaModelException {
+        Iterator<AnnotationDefinition> annotationIter = annotationDefinitions.iterator();
+        while (annotationIter.hasNext()) {
+            AnnotationDefinition annotationDefinition = annotationIter.next();
+            
+            if (element instanceof IType) {
+                IType type = (IType) element;
+                if (isClassRestricted(type, annotationDefinition)
+                        || isInterfaceRestricted(type, annotationDefinition)
+                        || isEnumRestricted(type, annotationDefinition)) {
+                    annotationIter.remove();
+                }
+            }
+            if (element instanceof IMethod) {
+                IMethod method = (IMethod) element;
+                if (method.isMainMethod()) {
+                    annotationIter.remove();
+                }
+                if (method.isConstructor()
+                        && !annotationDefinition.getTargets().contains(ElementType.CONSTRUCTOR)) {
+                    annotationIter.remove();
+                }
+
+                if (isClassRestricted(method, annotationDefinition)
+                        || isInterfaceRestricted(method, annotationDefinition)
+                        || isEnumRestricted(method, annotationDefinition)) {
+                    annotationIter.remove();
+                }
+            }
+            
+            if (element instanceof IField) {
+                if(isClassRestricted((IField) element, annotationDefinition)
+                        || isInterfaceRestricted((IField) element, annotationDefinition)
+                        ||isEnumRestricted((IField) element, annotationDefinition)) {
+                    annotationIter.remove();
+                }
+            }
+        }
+    }
+    
+    private static boolean isClassRestricted(IJavaElement javaElement, AnnotationDefinition annotationDefinition) 
+            throws JavaModelException {
+        if (javaElement.getElementType() == IJavaElement.TYPE) {
+            return !((IType)javaElement).isClass() && annotationDefinition.isClassOnly();
+        }
+        if (javaElement.getElementType() == IJavaElement.METHOD) {
+            IType type = (IType)javaElement.getParent();
+            return !type.isClass() && annotationDefinition.isClassOnly();
+        }
+        if (javaElement.getElementType() == IJavaElement.FIELD) {
+            IType type = (IType)javaElement.getParent();
+            return !type.isClass() && annotationDefinition.isClassOnly();
+        }
+        return false;
+    }
+    
+    private static boolean isInterfaceRestricted(IJavaElement javaElement, AnnotationDefinition annotationDefinition) 
+            throws JavaModelException {
+        if (javaElement.getElementType() == IJavaElement.TYPE) {
+            return !((IType)javaElement).isInterface() && annotationDefinition.isInterfaceOnly();
+        }
+        if (javaElement.getElementType() == IJavaElement.METHOD) {
+            IType type = (IType)javaElement.getParent();
+            return !type.isInterface()  && annotationDefinition.isInterfaceOnly();
+        }
+        if (javaElement.getElementType() == IJavaElement.FIELD) {
+            IType type = (IType)javaElement.getParent();
+            return !type.isInterface() && annotationDefinition.isInterfaceOnly();
+        }
+        return false;
+    }
+    
+    private static boolean isEnumRestricted(IJavaElement javaElement, AnnotationDefinition annotationDefinition) 
+            throws JavaModelException {
+        if (javaElement.getElementType() == IJavaElement.TYPE) {
+            return !((IType)javaElement).isEnum() && annotationDefinition.isEnumOnly();            
+        }
+        if (javaElement.getElementType() == IJavaElement.METHOD) {
+            IType type = (IType)javaElement.getParent();
+            return !type.isEnum() && annotationDefinition.isEnumOnly();            
+        }
+        if (javaElement.getElementType() == IJavaElement.FIELD) {
+            IType type = (IType)javaElement.getParent();
+            return !type.isEnum() && annotationDefinition.isEnumOnly();            
+        }
+        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;
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/IAnnotationAttributeInitializer.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/IAnnotationAttributeInitializer.java
new file mode 100644
index 0000000..1e96004
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/IAnnotationAttributeInitializer.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations;
+
+import java.util.List;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public interface IAnnotationAttributeInitializer {  
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends java.lang.annotation.Annotation> annotationClass);
+
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends java.lang.annotation.Annotation> annotationClass);
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/RequestWrapperAttributeInitializer.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/RequestWrapperAttributeInitializer.java
new file mode 100644
index 0000000..56de815
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/RequestWrapperAttributeInitializer.java
@@ -0,0 +1,87 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations.initialization;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationAttributeInitializerAdapter;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationsCore;
+import org.eclipse.jst.ws.internal.jaxws.core.utils.AnnotationUtils;
+import org.eclipse.jst.ws.internal.jaxws.core.utils.JDTUtils;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class RequestWrapperAttributeInitializer extends AnnotationAttributeInitializerAdapter {
+    private static final String CLASS_NAME = "className";
+    private static final String LOCAL_NAME = "localName";
+    private static final String TARGET_NAMESPACE = "targetNamespace";
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+
+        try {
+            IType type = member.getCompilationUnit().findPrimaryType();
+            IMethod method = (IMethod)member;
+    
+            String methodName = method.getElementName();
+            String packageName = type.getPackageFragment().getElementName();
+            if (packageName == null || packageName.length() == 0) {
+                packageName = "default_package"; //$NON-NLS-1$
+            }
+            packageName += "."; //$NON-NLS-1$
+
+            String className = packageName + methodName.substring(0, 1).toUpperCase(Locale.getDefault())
+                    + methodName.substring(1);
+            
+            String overloadedSuffix = AnnotationUtils.accountForOverloadedMethods(type, method);
+            
+            MemberValuePair classNameValuePair = AnnotationsCore.getStringMemberValuePair(ast, CLASS_NAME,
+                    className + overloadedSuffix);
+
+            MemberValuePair localNameValuePair = AnnotationsCore.getStringMemberValuePair(ast, LOCAL_NAME,
+                    methodName + overloadedSuffix);
+
+            MemberValuePair targetNamespaceValuePair = AnnotationsCore.getStringMemberValuePair(ast, TARGET_NAMESPACE,
+                    JDTUtils.getTargetNamespaceFromPackageName(packageName));
+
+            memberValuePairs.add(classNameValuePair);
+            memberValuePairs.add(localNameValuePair);
+            memberValuePairs.add(targetNamespaceValuePair);
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return memberValuePairs;
+    }
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return Collections.emptyList();
+    }
+
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/ResponseWrapperAttributeInitializer.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/ResponseWrapperAttributeInitializer.java
new file mode 100644
index 0000000..27bf303
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/ResponseWrapperAttributeInitializer.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations.initialization;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationAttributeInitializerAdapter;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationsCore;
+import org.eclipse.jst.ws.internal.jaxws.core.utils.AnnotationUtils;
+import org.eclipse.jst.ws.internal.jaxws.core.utils.JDTUtils;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class ResponseWrapperAttributeInitializer extends AnnotationAttributeInitializerAdapter {
+    private static final String CLASS_NAME = "className";
+    private static final String LOCAL_NAME = "localName";
+    private static final String TARGET_NAMESPACE = "targetNamespace";
+    
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+
+        try {
+            IType type = member.getCompilationUnit().findPrimaryType();
+            IMethod method = (IMethod)member;
+    
+            String methodName = method.getElementName() + "Response"; //$NON-NLS-1$
+            String packageName = type.getPackageFragment().getElementName();
+            if (packageName == null || packageName.length() == 0) {
+                packageName = "default_package"; //$NON-NLS-1$
+            }
+            packageName += "."; //$NON-NLS-1$
+            
+            String className = packageName + methodName.substring(0, 1).toUpperCase(Locale.getDefault())
+                    + methodName.substring(1);
+
+            String overloadedSuffix = AnnotationUtils.accountForOverloadedMethods(type, method);
+
+            MemberValuePair classNameValuePair = AnnotationsCore.getStringMemberValuePair(ast, CLASS_NAME,
+                    className + overloadedSuffix);
+
+            MemberValuePair localNameValuePair = AnnotationsCore.getStringMemberValuePair(ast, LOCAL_NAME,
+                    methodName + overloadedSuffix);
+
+            MemberValuePair targetNamespaceValuePair = AnnotationsCore.getStringMemberValuePair(ast, TARGET_NAMESPACE,
+                    JDTUtils.getTargetNamespaceFromPackageName(packageName));
+
+            memberValuePairs.add(classNameValuePair);
+            memberValuePairs.add(localNameValuePair);
+            memberValuePairs.add(targetNamespaceValuePair);
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return memberValuePairs;
+    }
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return Collections.emptyList();
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebMethodAttributeInitializer.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebMethodAttributeInitializer.java
new file mode 100644
index 0000000..187565f
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebMethodAttributeInitializer.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations.initialization;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationAttributeInitializerAdapter;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationsCore;
+import org.eclipse.jst.ws.internal.jaxws.core.utils.AnnotationUtils;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class WebMethodAttributeInitializer extends AnnotationAttributeInitializerAdapter {
+    private static final String OPERATION_NAME = "operationName";
+    
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+        
+        try {
+            IType type = member.getCompilationUnit().findPrimaryType();
+            IMethod method = (IMethod)member;
+            MemberValuePair operationValuePair = AnnotationsCore.getStringMemberValuePair(ast, OPERATION_NAME,
+                    method.getElementName() + AnnotationUtils.accountForOverloadedMethods(type, method));
+    
+            memberValuePairs.add(operationValuePair);
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return memberValuePairs;
+    }
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return Collections.emptyList();
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebParamAttributeInitializer.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebParamAttributeInitializer.java
new file mode 100644
index 0000000..b4f3024
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebParamAttributeInitializer.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations.initialization;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationAttributeInitializerAdapter;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationsCore;
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class WebParamAttributeInitializer extends AnnotationAttributeInitializerAdapter {
+    private static final String NAME = "name";
+    
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+        MemberValuePair nameValuePair = AnnotationsCore.getStringMemberValuePair(ast, NAME,
+                ((SingleVariableDeclaration)astNode).getName().getIdentifier());
+        memberValuePairs.add(nameValuePair);
+
+        return memberValuePairs;
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebServiceAttributeInitializer.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebServiceAttributeInitializer.java
new file mode 100644
index 0000000..8c84f8e
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/annotations/initialization/WebServiceAttributeInitializer.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jaxws.core.annotations.initialization;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.jdt.core.IMember;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationAttributeInitializerAdapter;
+import org.eclipse.jst.ws.internal.jaxws.core.annotations.AnnotationsCore;
+import org.eclipse.jst.ws.internal.jaxws.core.utils.JDTUtils;
+
+/**
+ * 
+ * @author sclarke
+ *
+ */
+public class WebServiceAttributeInitializer extends AnnotationAttributeInitializerAdapter {
+    private static final String TARGET_NAMESPACE = "targetNamespace";
+    private static final String PORT = "Port"; //$NON-NLS-1$
+    private static final String SERVICE = "Service"; //$NON-NLS-1$
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(IMember member, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+
+        String typeName = member.getElementName();
+        IType type = member.getCompilationUnit().findPrimaryType();
+        
+        String packageName = type.getPackageFragment().getElementName();
+
+        MemberValuePair nameValuePair = AnnotationsCore.getNameValuePair(ast, typeName);
+
+        MemberValuePair targetNamespaceValuePair = AnnotationsCore.getStringMemberValuePair(ast, TARGET_NAMESPACE,
+                JDTUtils.getTargetNamespaceFromPackageName(packageName));
+
+        MemberValuePair portNameValuePair = AnnotationsCore.getPortNameValuePair(ast, typeName
+                + PORT); //$NON-NLS-1$
+
+        MemberValuePair serviceNameValuePair = AnnotationsCore.getServiceNameValuePair(ast,
+                typeName + SERVICE); //$NON-NLS-1$
+
+        memberValuePairs.add(nameValuePair);
+        memberValuePairs.add(targetNamespaceValuePair);
+        memberValuePairs.add(portNameValuePair);
+        memberValuePairs.add(serviceNameValuePair);
+
+        return memberValuePairs;
+    }
+
+    @Override
+    public List<MemberValuePair> getMemberValuePairs(ASTNode astNode, AST ast,
+            Class<? extends Annotation> annotationClass) {
+        return Collections.emptyList();
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/utils/AnnotationUtils.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/utils/AnnotationUtils.java
new file mode 100644
index 0000000..5c1a404
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/utils/AnnotationUtils.java
@@ -0,0 +1,1145 @@
+/*******************************************************************************
+ * Copyright (c) 2008 IONA Technologies PLC
+ * 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:
+ * IONA Technologies PLC - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.ws.internal.jaxws.core.utils;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.filebuffers.FileBuffers;
+import org.eclipse.core.filebuffers.ITextFileBufferManager;
+import org.eclipse.core.filebuffers.LocationKind;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jdt.core.IAnnotation;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IField;
+import org.eclipse.jdt.core.IJavaElement;
+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.ASTParser;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
+import org.eclipse.jdt.core.dom.Annotation;
+import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
+import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
+import org.eclipse.jdt.core.dom.BodyDeclaration;
+import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.EnumDeclaration;
+import org.eclipse.jdt.core.dom.FieldDeclaration;
+import org.eclipse.jdt.core.dom.IExtendedModifier;
+import org.eclipse.jdt.core.dom.MemberValuePair;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.Name;
+import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jdt.core.dom.PackageDeclaration;
+import org.eclipse.jdt.core.dom.QualifiedName;
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
+import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+import org.eclipse.ltk.core.refactoring.TextFileChange;
+import org.eclipse.text.edits.MultiTextEdit;
+import org.eclipse.text.edits.TextEdit;
+import org.eclipse.text.edits.TextEditGroup;
+
+/**
+ * @author sclarke
+ * 
+ */
+public final class AnnotationUtils {
+    public static final String WEB_SERVICE = "WebService"; //$NON-NLS-1$
+    public static final String WEB_METHOD = "WebMethod"; //$NON-NLS-1$
+    public static final String WEB_PARAM = "WebParam"; //$NON-NLS-1$
+    public static final String REQUEST_WRAPPER = "RequestWrapper"; //$NON-NLS-1$
+    public static final String RESPONSE_WRAPPER = "ResponseWrapper"; //$NON-NLS-1$
+    
+    private static final String FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR 
+            = "org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator"; //$NON-NLS-1$
+    private static final String FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR 
+            = "org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator"; //$NON-NLS-1$
+    private static final String DO_NOT_INSERT 
+            = "do not insert"; //$NON-NLS-1$
+    private AnnotationUtils() {
+    }
+
+    /*
+    public static void getWebServiceAnnotationChange(IType type, 
+    		TextFileChange textFileChange) throws CoreException {
+        ICompilationUnit source = type.getCompilationUnit();
+
+        CompilationUnit compilationUnit = getASTParser(source);
+        
+        AST ast = compilationUnit.getAST();
+        ASTRewrite rewriter = ASTRewrite.create(ast);
+        
+        String typeName = type.getElementName();
+        String packageName = type.getPackageFragment().getElementName();
+
+        List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
+
+        MemberValuePair nameValuePair = AnnotationsCore.getNameValuePair(ast, typeName);
+
+//        MemberValuePair targetNamespaceValuePair = AnnotationsCore.getTargetNamespaceValuePair(
+//                compilationUnit, model.getTargetNamespace());
+
+        MemberValuePair portNameValuePair = AnnotationsCore.getPortNameValuePair(ast, typeName
+                + "Port"); //$NON-NLS-1$
+
+        MemberValuePair serviceNameValuePair = AnnotationsCore.getServiceNameValuePair(ast,
+                typeName + "Service"); //$NON-NLS-1$
+
+//        if (model.isUseServiceEndpointInterface()) {
+//            try {
+//                if (type.isInterface()) {
+//                    memberValuePairs.add(nameValuePair);
+//                    memberValuePairs.add(targetNamespaceValuePair);
+//                } else if (type.isClass()) {
+//                    MemberValuePair endpointInterfaceValuePair = AnnotationsCore
+//                            .getEndpointInterfaceValuePair(compilationUnit, model
+//                                    .getFullyQualifiedJavaInterfaceName());
+//                    memberValuePairs.add(endpointInterfaceValuePair);
+//                    memberValuePairs.add(portNameValuePair);
+//                    memberValuePairs.add(serviceNameValuePair);
+//                    
+//                    if  (packageName == null || packageName.length() == 0) {
+//                        memberValuePairs.add(targetNamespaceValuePair);
+//                    }
+//                    
+//                }
+//            } catch (JavaModelException jme) {
+//                JAXWSCorePlugin.log(jme.getStatus());
+//            }
+//        } else {
+            memberValuePairs.add(nameValuePair);
+//            memberValuePairs.add(targetNamespaceValuePair);
+            memberValuePairs.add(portNameValuePair);
+            memberValuePairs.add(serviceNameValuePair);
+//        }
+
+        Annotation annotation = AnnotationsCore.getAnnotation(ast, WebService.class, memberValuePairs);
+        AnnotationUtils.createTypeAnnotationChange(source, compilationUnit, rewriter, annotation, 
+        		textFileChange);
+    }*/
+
+    @SuppressWarnings("unchecked")
+    public static void getImportChange(CompilationUnit compilationUnit, 
+            Class<? extends java.lang.annotation.Annotation> annotation, TextFileChange textFileChange, 
+            boolean annotate) {
+        try {
+            String qualifiedName = annotation.getCanonicalName();
+            ImportRewrite importRewrite = ImportRewrite.create(compilationUnit, true);
+            if (annotate) {
+                importRewrite.addImport(qualifiedName);
+            } else {
+                final String annotationSimpleName = annotation.getSimpleName();
+                final List<String> occurences = new ArrayList<String>();
+                Target target = annotation.getAnnotation(Target.class);
+                List<ElementType> elementTypes = Arrays.asList(target.value());
+                for (ElementType elementType : elementTypes) {
+                    //TODO Handle package annotation imports
+                    if (elementType == ElementType.TYPE) {
+                        compilationUnit.accept(new ASTVisitor() {
+                            @Override
+                            public boolean visit(TypeDeclaration typeDeclaration) {
+                                countAnnotationOccurences(typeDeclaration.modifiers(), annotationSimpleName,
+                                        occurences);
+                                return super.visit(typeDeclaration);
+                            }
+                        });
+                    }
+                    if (elementType == ElementType.FIELD) {
+                        compilationUnit.accept(new ASTVisitor() {
+                            @Override
+                            public boolean visit(FieldDeclaration fieldDeclaration) {
+                                countAnnotationOccurences(fieldDeclaration.modifiers(), annotationSimpleName,
+                                        occurences);
+                                return super.visit(fieldDeclaration);
+                            }
+                        });
+                    }
+                    if (elementType == ElementType.METHOD) {
+                        compilationUnit.accept(new ASTVisitor() {
+                            @Override
+                            public boolean visit(MethodDeclaration methodDeclaration) {
+                                countAnnotationOccurences(methodDeclaration.modifiers(), annotationSimpleName,
+                                        occurences);                              
+                                return super.visit(methodDeclaration);
+                            }
+                        });
+                    }
+                    if (elementType == ElementType.PARAMETER) {
+                        compilationUnit.accept(new ASTVisitor() {
+                            @Override
+                            public boolean visit(SingleVariableDeclaration singleVariableDeclaration) {
+                                countAnnotationOccurences(singleVariableDeclaration.modifiers(),
+                                        annotationSimpleName, occurences);
+                                return super.visit(singleVariableDeclaration);
+                            }
+                        });
+                    }
+                }
+                if (occurences.size() == 1) {
+                    importRewrite.removeImport(qualifiedName);   
+                }
+            }
+            if (importRewrite.hasRecordedChanges()) {
+                    TextEdit importTextEdit = importRewrite.rewriteImports(null);
+                    textFileChange.addEdit(importTextEdit);
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        }
+    }
+    
+    private static void countAnnotationOccurences(List<IExtendedModifier> modifiers, String annotationSimpleName, 
+            List<String> occurences) {
+        for (IExtendedModifier extendedModifier : modifiers) {
+            if (extendedModifier instanceof Annotation) {
+                Annotation existingAnnotation = (Annotation) extendedModifier;
+                if (AnnotationUtils.getAnnotationName(existingAnnotation).equals(annotationSimpleName)) {
+                    occurences.add(annotationSimpleName);
+                }
+            }
+        }
+    }
+
+    public static void createPackageDeclarationAnnotationChange(ICompilationUnit source, 
+            PackageDeclaration packageDeclaration, ASTRewrite rewriter, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            if (packageDeclaration != null && !isAnnotationPresent(packageDeclaration, annotation)) {
+                bufferManager.connect(path, LocationKind.IFILE, monitor);
+                IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+                ListRewrite listRewrite = rewriter.getListRewrite(packageDeclaration,
+                        PackageDeclaration.ANNOTATIONS_PROPERTY);
+
+                listRewrite.insertFirst(annotation, null);
+
+                TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                        .getOptions(true));
+
+                textFileChange.addEdit(annotationTextEdit);
+
+                textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                        TextEdit[] { annotationTextEdit }));
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void removeAnnotationFromPackageDeclaration(ICompilationUnit source,
+            PackageDeclaration packageDeclaration, ASTRewrite rewriter, Annotation annotation,
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            if (packageDeclaration != null && isAnnotationPresent(packageDeclaration, annotation)) {
+                bufferManager.connect(path, LocationKind.IFILE, monitor);
+                IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+                ListRewrite listRewrite = rewriter.getListRewrite(packageDeclaration,
+                        PackageDeclaration.ANNOTATIONS_PROPERTY);
+
+                List originalList = listRewrite.getOriginalList();
+                for (Object object : originalList) {
+                    if (object instanceof Annotation && compareAnnotations((Annotation) object, annotation)) {
+                        listRewrite.remove((Annotation) object, null);
+                    }
+                }
+
+                TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                        .getOptions(true));
+
+                textFileChange.addEdit(annotationTextEdit);
+
+                textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                        TextEdit[] { annotationTextEdit }));
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void createTypeAnnotationChange(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = compilationUnit.getTypeRoot().findPrimaryType();
+            List<TypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type)
+                        && !isAnnotationPresent(abstractTypeDeclaration, annotation)) {
+                    bufferManager.connect(path, LocationKind.IFILE, monitor);
+                    IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                            .getDocument();
+
+                    ListRewrite listRewrite = rewriter.getListRewrite(abstractTypeDeclaration,
+                            getChildListPropertyDescriptorForType(abstractTypeDeclaration));
+                    
+                    listRewrite.insertFirst(annotation, null);
+
+                    TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                            .getOptions(true));
+
+                    textFileChange.addEdit(annotationTextEdit);
+
+                    textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                            TextEdit[] { annotationTextEdit }));
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static void removeAnnotationFromType(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = compilationUnit.getTypeRoot().findPrimaryType();
+            List<TypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type) 
+                        && isAnnotationPresent(abstractTypeDeclaration, annotation)) {
+                    bufferManager.connect(path, LocationKind.IFILE, monitor);
+                    IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                            .getDocument();
+
+                    ListRewrite listRewrite = rewriter.getListRewrite(abstractTypeDeclaration,
+                            getChildListPropertyDescriptorForType(abstractTypeDeclaration));
+
+                    List originalList = listRewrite.getOriginalList();
+                    for (Object object : originalList) {
+                        if (object instanceof Annotation && compareAnnotations((Annotation)object, 
+                                annotation)) {
+                            listRewrite.remove((Annotation)object, null);
+                        }
+                    }
+                    
+                    TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                            .getOptions(true));
+                     
+                    textFileChange.addEdit(annotationTextEdit);
+
+                    textFileChange.addTextEditGroup(new TextEditGroup("AA", new  //$NON-NLS-1$
+                             TextEdit[] {annotationTextEdit}));
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void createMethodAnnotationChange(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, IMethod method, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = method.getDeclaringType();
+            List<AbstractTypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type)) {
+                    List<BodyDeclaration> bodyDeclarations = JDTUtils
+                            .getBodyDeclarationsForType(abstractTypeDeclaration);
+                    BodyDeclaration bodyDeclaration = getMethodDeclaration(bodyDeclarations, method);
+                    if (!isAnnotationPresent(bodyDeclaration, annotation)) {
+                        bufferManager.connect(path, LocationKind.IFILE, monitor);
+                        IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                                .getDocument();
+                        
+                        ListRewrite listRewrite = rewriter.getListRewrite(bodyDeclaration,
+                                getChildListPropertyDescriptorForMethod(bodyDeclaration));
+                        listRewrite.insertAt(annotation, 0, null);
+
+                        TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                                .getOptions(true));
+
+                        textFileChange.addEdit(annotationTextEdit);
+                        textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                TextEdit[] { annotationTextEdit }));
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void removeAnnotationFromMethod(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, IMethod method, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = method.getDeclaringType();
+            List<AbstractTypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type)) {
+                    List<BodyDeclaration> bodyDeclarations = JDTUtils
+                            .getBodyDeclarationsForType(abstractTypeDeclaration);
+                    BodyDeclaration bodyDeclaration = getMethodDeclaration(bodyDeclarations, method);
+                    if (isAnnotationPresent(bodyDeclaration, annotation)) {
+                        bufferManager.connect(path, LocationKind.IFILE, monitor);
+                        IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                                .getDocument();
+
+                        ListRewrite listRewrite = rewriter.getListRewrite(bodyDeclaration,
+                                getChildListPropertyDescriptorForMethod(bodyDeclaration));
+
+                        List originalList = listRewrite.getOriginalList();
+                        for (Object object : originalList) {
+                            if (object instanceof Annotation
+                                    && compareAnnotations((Annotation) object, annotation)) {
+                                listRewrite.remove((Annotation) object, null);
+                            }
+                        }
+
+                        TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                                .getOptions(true));
+
+                        textFileChange.addEdit(annotationTextEdit);
+                        textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                TextEdit[] { annotationTextEdit }));
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static void createFiedlAnnotationChange(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, IField field, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = field.getDeclaringType();
+            List<AbstractTypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type)) {
+                    List<BodyDeclaration> bodyDeclarations = JDTUtils
+                            .getBodyDeclarationsForType(abstractTypeDeclaration);
+                    FieldDeclaration fieldDeclaration = (FieldDeclaration) getFieldDeclaration(
+                            bodyDeclarations, field);
+                    if (!isAnnotationPresent(fieldDeclaration, annotation)) {
+                        bufferManager.connect(path, LocationKind.IFILE, monitor);
+                        IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                                .getDocument();
+
+                        ListRewrite listRewrite = rewriter.getListRewrite(fieldDeclaration,
+                                FieldDeclaration.MODIFIERS2_PROPERTY);
+                        listRewrite.insertAt(annotation, 0, null);
+
+                        TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                                .getOptions(true));
+
+                        textFileChange.addEdit(annotationTextEdit);
+                        textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                TextEdit[] { annotationTextEdit }));
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void removeAnnotationFromField(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, IField field, Annotation annotation, 
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = field.getDeclaringType();
+            List<AbstractTypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type)) {
+                    List<BodyDeclaration> bodyDeclarations = JDTUtils
+                            .getBodyDeclarationsForType(abstractTypeDeclaration);
+                    FieldDeclaration fieldDeclaration = (FieldDeclaration) getFieldDeclaration(
+                            bodyDeclarations, field);
+
+                    if (isAnnotationPresent(fieldDeclaration, annotation)) {
+                        bufferManager.connect(path, LocationKind.IFILE, monitor);
+                        IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                                .getDocument();
+
+                        ListRewrite listRewrite = rewriter.getListRewrite(fieldDeclaration,
+                                FieldDeclaration.MODIFIERS2_PROPERTY);
+
+                        List originalList = listRewrite.getOriginalList();
+                        for (Object object : originalList) {
+                            if (object instanceof Annotation
+                                    && compareAnnotations((Annotation) object, annotation)) {
+                                listRewrite.remove((Annotation) object, null);
+                            }
+                        }
+
+                        TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                                .getOptions(true));
+
+                        textFileChange.addEdit(annotationTextEdit);
+                        textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                TextEdit[] { annotationTextEdit }));
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+   
+    @SuppressWarnings("unchecked")
+    public static void createMethodParameterAnnotationChange(ICompilationUnit source, CompilationUnit 
+            compilationUnit, ASTRewrite rewriter, SingleVariableDeclaration singleVariableDeclaration, 
+            IMethod method, Annotation annotation, TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            IType type = method.getDeclaringType();
+            List<AbstractTypeDeclaration> types = compilationUnit.types();
+            for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+                if (compareTypes(abstractTypeDeclaration, type)) {
+                    List<BodyDeclaration> bodyDeclarations = JDTUtils
+                            .getBodyDeclarationsForType(abstractTypeDeclaration);
+                    MethodDeclaration methodDeclaration = (MethodDeclaration) getMethodDeclaration(
+                            bodyDeclarations, method);
+
+                    List<SingleVariableDeclaration> parameters = methodDeclaration.parameters();
+                    for (SingleVariableDeclaration parameter : parameters) {
+                        if (compareMethodParameters(parameter, singleVariableDeclaration)
+                                && !isAnnotationPresent(parameter, annotation)) {
+                            bufferManager.connect(path, LocationKind.IFILE, monitor);
+                            IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                                    .getDocument();
+
+                            ListRewrite listRewrite = rewriter.getListRewrite(parameter,
+                                    SingleVariableDeclaration.MODIFIERS2_PROPERTY);
+
+                            listRewrite.insertAt(annotation, -1, null);
+
+                            TextEdit annotationTextEdit = rewriter.rewriteAST(document, source
+                                    .getJavaProject().getOptions(true));
+
+                            textFileChange.addEdit(annotationTextEdit);
+
+                            textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                    TextEdit[] { annotationTextEdit }));
+                        }
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }        
+    }
+    
+    public static void createMethodParameterAnnotationChange(ICompilationUnit source, ASTRewrite rewriter,
+            SingleVariableDeclaration singleVariableDeclaration, Annotation annotation,
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            if (!isAnnotationPresent(singleVariableDeclaration, annotation)) {
+                bufferManager.connect(path, LocationKind.IFILE, monitor);
+                IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+                ListRewrite listRewrite = rewriter.getListRewrite(singleVariableDeclaration,
+                        SingleVariableDeclaration.MODIFIERS2_PROPERTY);
+
+                listRewrite.insertAt(annotation, -1, null);
+
+                TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                        .getOptions(true));
+
+                textFileChange.addEdit(annotationTextEdit);
+
+                textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                        TextEdit[] { annotationTextEdit }));
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void removeAnnotationFromMethodParameter(ICompilationUnit source, ASTRewrite rewriter,
+            SingleVariableDeclaration singleVariableDeclaration, Annotation annotation,
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            if (isAnnotationPresent(singleVariableDeclaration, annotation)) {
+                bufferManager.connect(path, LocationKind.IFILE, monitor);
+                IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+                ListRewrite listRewrite = rewriter.getListRewrite(singleVariableDeclaration,
+                        SingleVariableDeclaration.MODIFIERS2_PROPERTY);
+
+                List originalList = listRewrite.getOriginalList();
+                for (Object object : originalList) {
+                    if (object instanceof Annotation && compareAnnotations((Annotation)object, annotation)) {
+                        listRewrite.remove((Annotation)object, null);
+                    }
+                }
+
+                TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject()
+                        .getOptions(true));
+
+                textFileChange.addEdit(annotationTextEdit);
+
+                textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                        TextEdit[] { annotationTextEdit }));
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static void createMemberVaulePairChange(ICompilationUnit source, CompilationUnit compilationUnit,
+            ASTRewrite rewriter, IJavaElement javaElement, IAnnotation annotation, ASTNode memberValuePair,
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            List<IExtendedModifier> modifiers = getExtendedModifiers(compilationUnit, javaElement);
+            for (IExtendedModifier extendedModifier : modifiers) {
+                if (extendedModifier instanceof NormalAnnotation) {
+                    NormalAnnotation existingAnnotation = (NormalAnnotation) extendedModifier;
+                    if (AnnotationUtils.compareAnnotations(annotation, existingAnnotation)) {
+                        bufferManager.connect(path, LocationKind.IFILE, monitor);
+                        IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE)
+                                .getDocument();
+
+                        ListRewrite listRewrite = rewriter.getListRewrite(existingAnnotation,
+                                NormalAnnotation.VALUES_PROPERTY);
+
+                        listRewrite.insertLast(memberValuePair, null);
+
+                        Map options = source.getJavaProject().getOptions(true);
+                        options.put(FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR, DO_NOT_INSERT);
+                        options.put(FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR, DO_NOT_INSERT);
+
+                        TextEdit annotationTextEdit = rewriter.rewriteAST(document, options);
+
+                        textFileChange.addEdit(annotationTextEdit);
+
+                        textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                TextEdit[] { annotationTextEdit }));
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void createMemberVaulePairChange(ICompilationUnit source, CompilationUnit compilationUnit,
+            ASTRewrite rewriter, NormalAnnotation annotation, ASTNode memberValuePair,
+            TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            bufferManager.connect(path, LocationKind.IFILE, monitor);
+            IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+            ListRewrite listRewrite = rewriter.getListRewrite(annotation,
+                    NormalAnnotation.VALUES_PROPERTY);
+
+            listRewrite.insertLast(memberValuePair, null);
+
+            Map options = source.getJavaProject().getOptions(true);
+            options.put(FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR, DO_NOT_INSERT);
+            options.put(FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR, DO_NOT_INSERT);
+
+            TextEdit annotationTextEdit = rewriter.rewriteAST(document, options);
+
+            textFileChange.addEdit(annotationTextEdit);
+
+            textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                    TextEdit[] { annotationTextEdit }));
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static void updateMemberVaulePairValue(ICompilationUnit source, CompilationUnit compilationUnit,
+            ASTRewrite rewriter, IJavaElement javaElement, IAnnotation annotation, IMemberValuePair memberValuePair,
+            ASTNode value, TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            List<IExtendedModifier> modifiers = getExtendedModifiers(compilationUnit, javaElement);
+            for (IExtendedModifier extendedModifier : modifiers) {
+                if (extendedModifier instanceof NormalAnnotation) {
+                    NormalAnnotation existingAnnotation = (NormalAnnotation) extendedModifier;
+                    if (AnnotationUtils.compareAnnotations(annotation, existingAnnotation)) {
+                        List<MemberValuePair> memberVaulePairs = existingAnnotation.values();
+                        for (MemberValuePair memberValuePairDOM : memberVaulePairs) {
+                            if (memberValuePairDOM.getName().toString().equals(
+                                    memberValuePair.getMemberName())) {
+                                bufferManager.connect(path, LocationKind.IFILE, monitor);
+                                IDocument document = bufferManager
+                                        .getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+                                rewriter.set(memberValuePairDOM, MemberValuePair.VALUE_PROPERTY, value, null);
+
+                                TextEdit annotationTextEdit = rewriter.rewriteAST(document, source
+                                        .getJavaProject().getOptions(true));
+
+                                textFileChange.addEdit(annotationTextEdit);
+
+                                textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                                        TextEdit[] { annotationTextEdit }));
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+
+    public static void updateMemberVaulePairValue(ICompilationUnit source, CompilationUnit compilationUnit,
+            ASTRewrite rewriter, NormalAnnotation annotation, MemberValuePair memberValuePair,
+            ASTNode value, TextFileChange textFileChange) throws CoreException {
+        IProgressMonitor monitor = new NullProgressMonitor();
+        IPath path = source.getResource().getFullPath();
+        ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
+        try {
+            bufferManager.connect(path, LocationKind.IFILE, monitor);
+            IDocument document = bufferManager.getTextFileBuffer(path, LocationKind.IFILE).getDocument();
+
+            rewriter.set(memberValuePair, MemberValuePair.VALUE_PROPERTY, value, null);
+
+            TextEdit annotationTextEdit = rewriter.rewriteAST(document, source.getJavaProject().getOptions(
+                    true));
+
+            textFileChange.addEdit(annotationTextEdit);
+
+            textFileChange.addTextEditGroup(new TextEditGroup("AA", new //$NON-NLS-1$
+                    TextEdit[] { annotationTextEdit }));
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        } finally {
+            bufferManager.disconnect(path, LocationKind.IFILE, monitor);
+        }
+    }
+    
+    private static ChildListPropertyDescriptor getChildListPropertyDescriptorForType(AbstractTypeDeclaration 
+            abstractTypeDeclaration) {
+        ChildListPropertyDescriptor childListPropertyDescriptor = null;
+        if (abstractTypeDeclaration instanceof TypeDeclaration) {
+            childListPropertyDescriptor = TypeDeclaration.MODIFIERS2_PROPERTY; 
+        }
+        if (abstractTypeDeclaration instanceof EnumDeclaration) {
+            childListPropertyDescriptor = EnumDeclaration.MODIFIERS2_PROPERTY;
+        }
+        if (abstractTypeDeclaration instanceof AnnotationTypeDeclaration) {
+            childListPropertyDescriptor = AnnotationTypeDeclaration.MODIFIERS2_PROPERTY;
+        }
+        return childListPropertyDescriptor;
+    }
+
+    private static ChildListPropertyDescriptor getChildListPropertyDescriptorForMethod(
+            BodyDeclaration bodyDeclaration) {
+        if (bodyDeclaration instanceof MethodDeclaration) {
+            return MethodDeclaration.MODIFIERS2_PROPERTY;
+        }
+        if (bodyDeclaration instanceof AnnotationTypeMemberDeclaration) {
+            return AnnotationTypeMemberDeclaration.MODIFIERS2_PROPERTY;
+        }
+        return null;
+    }
+
+    public static CompilationUnit getASTParser(ICompilationUnit source) {
+        ASTParser parser = ASTParser.newParser(AST.JLS3);
+        parser.setSource(source);
+        CompilationUnit compilationUnit = (CompilationUnit) parser.createAST(new NullProgressMonitor());
+        compilationUnit.recordModifications();
+        return compilationUnit;
+    }
+    
+    public static TextFileChange createTextFileChange(String textFileChangeName, IFile file) {
+        TextFileChange textFileChange = new TextFileChange(textFileChangeName, file);
+        MultiTextEdit multiTextEdit = new MultiTextEdit();
+        textFileChange.setEdit(multiTextEdit);
+        return textFileChange;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static List<SingleVariableDeclaration> getMethodParameters(IType type, final IMethod method) {
+        ICompilationUnit source = type.getCompilationUnit();
+        CompilationUnit compilationUnit = getASTParser(source);
+        final List<SingleVariableDeclaration> parameters = new ArrayList();
+        compilationUnit.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodDeclaration methodDeclaration) {
+                if (compareMethods(methodDeclaration, method)) {
+                    parameters.addAll(methodDeclaration.parameters());
+                }
+                return super.visit(methodDeclaration);
+            }
+        });     
+        return parameters;
+    }
+
+    public static String getAnnotationName(Annotation annotation) {
+        Name annotationTypeName = annotation.getTypeName();
+        String annotationName = annotationTypeName.getFullyQualifiedName();
+        if (annotationTypeName.isQualifiedName()) {
+            annotationName = ((QualifiedName) annotationTypeName).getName().getFullyQualifiedName();
+        }
+        return annotationName;
+    }
+    
+    public static boolean compareTypes(AbstractTypeDeclaration abstractTypeDeclaration, IType type) {
+        return abstractTypeDeclaration.getName().getIdentifier().equals(type.getElementName());
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static boolean compareMethods(MethodDeclaration methodDeclaration, IMethod method) {
+    	if (methodDeclaration.getName().getIdentifier().equals(method.getElementName())) {
+	    	String[] parametetNames = method.getParameterTypes();
+	    	List<SingleVariableDeclaration> methodDeclarationParameters = methodDeclaration.parameters();
+	    	if (parametetNames.length == methodDeclarationParameters.size()) {
+		    	for (int i = 0; i < parametetNames.length; i++) {
+					String simpleName1 = Signature.getSimpleName(Signature.toString(Signature
+							.getTypeErasure(parametetNames[i])));
+					String simpleName2 = methodDeclarationParameters.get(i).getType().toString();
+					if (!simpleName1.equals(simpleName2)) {
+						return false;
+					}
+				}
+		    	return true;
+	    	}
+    	}
+    	return false;
+	}
+    
+    public static boolean compareMethods(AnnotationTypeMemberDeclaration memmberDeclaration, IMethod method) {
+        if (memmberDeclaration.getName().getIdentifier().equals(method.getElementName())) {
+                return true;
+        }
+        return false;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static boolean compareFields(FieldDeclaration fieldDeclaration, IField field) {
+        List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
+        for (VariableDeclarationFragment variableDeclarationFragment : fragments) {
+           if (variableDeclarationFragment.getName().getIdentifier().equals(field.getElementName())) {
+               return true;
+           }
+        }
+        return false;
+    }
+
+    public static String accountForOverloadedMethods(IType type, IMethod method) throws JavaModelException {
+    	List<IMethod> methods =  Arrays.asList(type.getMethods());
+    	List<IMethod> similarMethods = new ArrayList<IMethod>();
+    	for (IMethod methodToTest : methods) {
+    		if (!method.equals(methodToTest) && method.getElementName().equalsIgnoreCase(
+    				methodToTest.getElementName()) && methodToTest.getSourceRange().getOffset() < 
+    				method.getSourceRange().getOffset()) {
+    			similarMethods.add(methodToTest);
+			}
+		}
+    	return similarMethods.size() > 0 ? Integer.toString(similarMethods.size()) : ""; //$NON-NLS-1$
+    }
+    
+    private static boolean compareAnnotations(Annotation newAnnotation, Annotation existingAnnotation) {
+        return AnnotationUtils.getAnnotationName(existingAnnotation).equals(
+                AnnotationUtils.getAnnotationName(newAnnotation));
+    }
+    
+    private static boolean compareAnnotations(IAnnotation newAnnotation, Annotation existingAnnotation) {
+        return AnnotationUtils.getAnnotationName(existingAnnotation).equals(newAnnotation.getElementName());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static boolean isAnnotationPresent(final IMethod method, final String annotationKey) {
+        ICompilationUnit source = method.getCompilationUnit();
+        CompilationUnit compilationUnit = getASTParser(source);
+        final List<MethodDeclaration> methodDeclarations = new ArrayList<MethodDeclaration>();
+        compilationUnit.accept(new ASTVisitor() {
+            @Override
+            public boolean visit(MethodDeclaration methodDeclaration) {
+                if (methodDeclaration.getName().getIdentifier().equals(method.getElementName())) {
+                    methodDeclarations.add(methodDeclaration);
+                }
+                return super.visit(methodDeclaration);
+            }
+        });
+
+        for (MethodDeclaration methodDeclaration : methodDeclarations) {
+            if (annotationKey.equals(AnnotationUtils.WEB_PARAM)) {
+                List<SingleVariableDeclaration> parameters = methodDeclaration.parameters();
+                for (SingleVariableDeclaration singleVariableDeclaration : parameters) {
+                    if (compareModifiers(singleVariableDeclaration.modifiers(), annotationKey)) {
+                        return true;
+                    }
+                }
+            } else {
+                 return compareModifiers(methodDeclaration.modifiers(), annotationKey);
+            }
+
+        }
+        return false;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static boolean isAnnotationPresent(SingleVariableDeclaration parameter,
+            Annotation annatotationToAdd) {
+        boolean exists = false;
+        List<IExtendedModifier> modifiers = parameter.modifiers();
+        for (IExtendedModifier extendedModifier : modifiers) {
+            if (extendedModifier instanceof Annotation) {
+                Annotation existingAnnotation = (Annotation) extendedModifier;
+                if (compareAnnotations(annatotationToAdd, existingAnnotation)) {
+                    return true;
+                }
+            }
+        }
+        return exists;
+    }
+    
+    public static boolean isAnnotationPresent(IJavaElement javaElement, String annotationName) {
+        if (javaElement.getElementType() == IJavaElement.COMPILATION_UNIT) {
+            return isAnnotationPresent(((ICompilationUnit)javaElement).findPrimaryType(), annotationName);
+        }
+        
+        
+        ICompilationUnit source = JDTUtils.getCompilationUnitFromFile((IFile)javaElement.getResource());
+        int elementType = javaElement.getElementType();
+        CompilationUnit compilationUnit = JDTUtils.getCompilationUnit(source);
+        if (elementType == IJavaElement.PACKAGE_DECLARATION) {
+            return isAnnotationPresent(compilationUnit.getPackage(), annotationName);
+        }
+        if (elementType == IJavaElement.TYPE || elementType == IJavaElement.METHOD || 
+                elementType == IJavaElement.FIELD) {
+            return isAnnotationPresent(compilationUnit, javaElement, annotationName);
+        }
+        return false;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static boolean isAnnotationPresent(PackageDeclaration packageDeclaration, String annotationName) {
+        List<Annotation> annotations = packageDeclaration.annotations();
+        for (Annotation existingAnnotation : annotations) {
+            if (AnnotationUtils.getAnnotationName(existingAnnotation).equals(annotationName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static boolean isAnnotationPresent(PackageDeclaration packageDeclaration, Annotation annotation) {
+        List<Annotation> annotations = packageDeclaration.annotations();
+        for (Annotation existingAnnotation : annotations) {
+            if (compareAnnotations(annotation, existingAnnotation)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    @SuppressWarnings("unchecked")
+    private static boolean isAnnotationPresent(BodyDeclaration bodyDeclaration, Annotation annatotationToAdd) {
+        boolean exists = false;
+        List<IExtendedModifier> modifiers = bodyDeclaration.modifiers();
+        for (IExtendedModifier extendedModifier : modifiers) {
+            if (extendedModifier instanceof Annotation) {
+                Annotation existingAnnotation = (Annotation) extendedModifier;
+                if (compareAnnotations(annatotationToAdd, existingAnnotation)) {
+                    return true;
+                }
+            }
+        }
+        return exists;
+    }
+
+    private static boolean isAnnotationPresent(CompilationUnit compilationUnit, IJavaElement javaElement,
+            String annotationName) {
+
+        List<IExtendedModifier> modifiers = getExtendedModifiers(compilationUnit, javaElement);
+        for (IExtendedModifier extendedModifier : modifiers) {
+            if (extendedModifier instanceof Annotation) {
+                Annotation existingAnnotation = (Annotation) extendedModifier;
+                if (AnnotationUtils.getAnnotationName(existingAnnotation).equals(annotationName)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<IExtendedModifier> getExtendedModifiers(CompilationUnit compilationUnit, 
+            IJavaElement javaElement) {
+        IType type = compilationUnit.getTypeRoot().findPrimaryType();
+        List<AbstractTypeDeclaration> types = compilationUnit.types();
+        for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+            if (compareTypes(abstractTypeDeclaration, type)) {
+                List<BodyDeclaration> bodyDeclarations = 
+                        JDTUtils.getBodyDeclarationsForType(abstractTypeDeclaration);
+                
+                BodyDeclaration bodyDeclaration = null;
+                if (javaElement.getElementType() == IJavaElement.TYPE) {
+                    bodyDeclaration = abstractTypeDeclaration;
+                }
+                
+                if (javaElement.getElementType() == IJavaElement.METHOD) {
+                    bodyDeclaration = getMethodDeclaration(bodyDeclarations, (IMethod) javaElement);
+                }
+                if (javaElement.getElementType() == IJavaElement.FIELD) {
+                    bodyDeclaration = getFieldDeclaration(bodyDeclarations, (IField) javaElement);
+                }   
+
+                return bodyDeclaration.modifiers();
+            }
+        }
+        return Collections.emptyList();
+    }
+    
+    private static BodyDeclaration getMethodDeclaration(List<BodyDeclaration> bodyDeclarations, IMethod method) {
+        for (BodyDeclaration bodyDeclaration : bodyDeclarations) {
+            if (bodyDeclaration instanceof MethodDeclaration) {
+                if (compareMethods((MethodDeclaration)bodyDeclaration, method)) {
+                    return bodyDeclaration;
+                }
+            }
+            if (bodyDeclaration instanceof AnnotationTypeMemberDeclaration) {
+                if (compareMethods((AnnotationTypeMemberDeclaration)bodyDeclaration, method)) {
+                    return bodyDeclaration;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static BodyDeclaration getFieldDeclaration(List<BodyDeclaration> bodyDeclarations, IField field) {
+        for (BodyDeclaration bodyDeclaration : bodyDeclarations) {
+            if (bodyDeclaration instanceof FieldDeclaration) {
+                if (compareFields((FieldDeclaration)bodyDeclaration, field)) {
+                    return bodyDeclaration;
+                }
+            }
+        }
+        return null;
+    }
+    
+    private static boolean compareMethodParameters(SingleVariableDeclaration paramOne,
+            SingleVariableDeclaration paramTwo) {
+        String typeOne = paramOne.getType().toString();
+        String nameOne = paramOne.getName().getIdentifier();
+
+        String typeTwo = paramTwo.getType().toString();
+        String nameTwo = paramTwo.getName().getIdentifier();
+
+        return (typeOne.equals(typeTwo)) && (nameOne.equals(nameTwo));
+    }
+
+    private static boolean compareModifiers(List<IExtendedModifier> modifiers, String annotationKey) {
+        for (IExtendedModifier extendedModifier : modifiers) {
+            if (extendedModifier instanceof Annotation) {
+                Annotation existingAnnotation = (Annotation) extendedModifier;
+                String annotationName = AnnotationUtils.getAnnotationName(existingAnnotation);
+                if (annotationName.equals(annotationKey)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
diff --git a/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/utils/JDTUtils.java b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/utils/JDTUtils.java
new file mode 100644
index 0000000..7ab3aaf
--- /dev/null
+++ b/bundles/org.eclipse.jst.ws.jaxws.core/src/org/eclipse/jst/ws/internal/jaxws/core/utils/JDTUtils.java
@@ -0,0 +1,382 @@
+/*******************************************************************************
+ * Copyright (c) 2008 IONA Technologies PLC
+ * 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:
+ * IONA Technologies PLC - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.ws.internal.jaxws.core.utils;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.filesystem.IFileStore;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaConventions;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTParser;
+import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
+import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
+import org.eclipse.jdt.core.dom.BodyDeclaration;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.EnumDeclaration;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCoreMessages;
+import org.eclipse.jst.ws.internal.jaxws.core.JAXWSCorePlugin;
+
+/**
+ * @author sclarke
+ */
+public final class JDTUtils {
+
+    private JDTUtils() {
+    }
+
+    public static void addToClasspath(IJavaProject javaProject, IClasspathEntry classpathEntry) {
+        try {
+            List<IClasspathEntry> currentEntries = Arrays.asList(javaProject.getRawClasspath());
+            List<IClasspathEntry> newEntries = new ArrayList<IClasspathEntry>();
+            newEntries.addAll(currentEntries);
+            if (classpathEntry != null && !newEntries.contains(classpathEntry)) {
+                newEntries.add(classpathEntry);
+            }
+            javaProject.setRawClasspath(newEntries.toArray(new IClasspathEntry[newEntries.size()]),
+                    new NullProgressMonitor());
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+    }
+
+    public static void removeFromClasspath(IJavaProject javaProject, IClasspathEntry classpathEntry) {
+        try {
+            List<IClasspathEntry> currentEntries = Arrays.asList(javaProject.getRawClasspath());
+            List<IClasspathEntry> newEntries = new ArrayList<IClasspathEntry>();
+            newEntries.addAll(currentEntries);
+            if (classpathEntry != null && newEntries.contains(classpathEntry)) {
+                newEntries.remove(classpathEntry);
+            }
+            javaProject.setRawClasspath(newEntries.toArray(new IClasspathEntry[newEntries.size()]),
+                    new NullProgressMonitor());
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+    }
+    
+    public static IStatus checkTypeExists(IType type, String compilationUnitName) {
+        compilationUnitName = compilationUnitName.trim();
+
+        IPackageFragment packageFragment = type.getPackageFragment();
+        ICompilationUnit compilationUnit = packageFragment.getCompilationUnit(compilationUnitName);
+        IResource resource = compilationUnit.getResource();
+
+        if (resource.exists()) {
+            return new Status(IStatus.ERROR, JAXWSCorePlugin.PLUGIN_ID, JAXWSCoreMessages
+                    .bind(JAXWSCoreMessages.TYPE_WITH_NAME_ALREADY_EXISTS, new Object[] {
+                            compilationUnitName, packageFragment.getElementName() }));
+        }
+        URI location = resource.getLocationURI();
+        if (location != null) {
+            try {
+                IFileStore fileStore = EFS.getStore(location);
+                if (fileStore.fetchInfo().exists()) {
+                    return new Status(IStatus.ERROR, JAXWSCorePlugin.PLUGIN_ID,
+                            JAXWSCoreMessages.TYPE_NAME_DIFFERENT_CASE_EXISTS);
+                }
+            } catch (CoreException ce) {
+                JAXWSCorePlugin.log(ce.getStatus());
+            }
+        }
+        return Status.OK_STATUS;
+    }
+    
+    public static String getClassName(String projectName, String fullyQualifiedClassName) {
+        return JDTUtils.getType(JDTUtils.getJavaProject(projectName), fullyQualifiedClassName)
+                .getElementName();
+    }
+
+    public static IJavaProject getJavaProject(IProject project) {
+        IJavaProject javaProject = JavaCore.create(project);
+        return javaProject;
+    }
+
+    public static IJavaProject getJavaProject(String projectName) {
+        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
+        return JDTUtils.getJavaProject(project);
+    }
+
+    public static String getJavaProjectOutputDirectoryPath(IJavaProject javaProject) {
+        IPath outputPath;
+        String fullPath = ""; //$NON-NLS-1$
+        try {
+            outputPath = javaProject.getOutputLocation();
+            fullPath = ResourcesPlugin.getWorkspace().getRoot().findMember(outputPath).getLocation()
+                    .toOSString();
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return fullPath;
+    }
+
+    public static String getJavaProjectOutputDirectoryPath(String projectName) {
+        return JDTUtils.getJavaProjectOutputDirectoryPath(JDTUtils.getJavaProject(projectName));
+    }
+
+    public static String getJavaProjectSourceDirectoryPath(IJavaProject javaProject,
+            String fullyQualifiedClassName) {
+        
+        IType type = JDTUtils.getType(javaProject, fullyQualifiedClassName);
+        IPackageFragment packageFragment = type.getPackageFragment();
+        IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot)packageFragment.getParent();
+        IResource srcDirectoryResource = packageFragmentRoot.getResource();
+        return srcDirectoryResource.getFullPath().toOSString();
+    }
+
+    public static String getJavaProjectSourceDirectoryPath(String projectName, 
+            String fullyQualifiedClassName) {
+        return JDTUtils.getJavaProjectSourceDirectoryPath(JDTUtils.getJavaProject(projectName),
+                fullyQualifiedClassName);
+    }
+
+    public static String getJavaProjectSourceDirectoryPath(String projectName) {
+        return JDTUtils.getJavaProjectSourceDirectoryPath(JDTUtils.getJavaProject(projectName));
+    }
+
+    public static String getJavaProjectSourceDirectoryPath(IProject project) {
+        return JDTUtils.getJavaProjectSourceDirectoryPath(JDTUtils.getJavaProject(project));
+    }
+    
+    public static String getJavaProjectSourceDirectoryPath(IJavaProject javaProject) {
+        try {
+            IPackageFragmentRoot[] packageFragmentRoots = javaProject.getAllPackageFragmentRoots();
+            IPackageFragmentRoot packageFragmentRoot = packageFragmentRoots[0];
+            IResource srcDirectoryResource = packageFragmentRoot.getResource();
+            return srcDirectoryResource.getFullPath().toOSString();
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return ""; //$NON-NLS-1$
+    }
+
+    public static String getPackageNameFromClass(IJavaProject javaProject, String fullyQualifiedClassName) {
+        return JDTUtils.getType(javaProject, fullyQualifiedClassName).getPackageFragment().getElementName();
+    }
+
+    public static String getPackageNameFromClass(String projectName, String fullyQualifiedClassName) {
+        return JDTUtils
+                .getPackageNameFromClass(JDTUtils.getJavaProject(projectName), fullyQualifiedClassName);
+    }
+
+    public static IMethod[] getPublicMethods(IType type) {
+        List<IMethod> publicMethods = new ArrayList<IMethod>();
+        try {
+            IMethod[] allMethods = type.getMethods();
+            for (int i = 0; i < allMethods.length; i++) {
+                IMethod method = allMethods[i];
+                if (Flags.isPublic(method.getFlags()) && !method.isConstructor() && !method.isMainMethod()) {
+                    publicMethods.add(method);
+                }
+            }
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return publicMethods.toArray(new IMethod[publicMethods.size()]);
+    }
+
+    public static String getSourceFromType(IType type) {
+        try {
+            return type.getCompilationUnit().getBuffer().getContents();
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return ""; //$NON-NLS-1$
+    }
+
+    public static String getTargetNamespaceFromPackageName(String packageName) {
+        if (packageName == null || packageName.length() == 0) {
+            return "http://default_package/"; //$NON-NLS-1$
+        }
+        List<String> namespaceElements = Arrays.asList(packageName.split("\\.")); //$NON-NLS-1$
+        Collections.reverse(namespaceElements);
+        String targetNamespace = "http://"; //$NON-NLS-1$
+
+        Iterator<String> namespaceIterator = namespaceElements.iterator();
+        while (namespaceIterator.hasNext()) {
+            String element = namespaceIterator.next();
+            if (element.trim().length() > 0) {
+                targetNamespace += element;
+                if (namespaceIterator.hasNext()) {
+                    targetNamespace += "."; //$NON-NLS-1$
+                }
+            }
+        }
+        targetNamespace += "/"; //$NON-NLS-1$
+        return targetNamespace;
+    }
+
+    public static IType getType(IJavaProject javaProject, String fullyQualifiedClassName) {
+        try {
+            return javaProject.findType(fullyQualifiedClassName);
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return null;
+    }
+
+    public static IType getType(IProject project, String fullyQualifiedClassName) {
+        return JDTUtils.getType(JDTUtils.getJavaProject(project), fullyQualifiedClassName);
+    }
+
+    public static IType getType(String projectName, String fullyQualifiedClassName) {
+        return JDTUtils.getType(JDTUtils.getJavaProject(projectName), fullyQualifiedClassName);
+    }
+
+    public static boolean isJavaProject(IProject project) {
+        try {
+            return project.hasNature(JavaCore.NATURE_ID);
+        } catch (CoreException ce) {
+            JAXWSCorePlugin.log(ce.getStatus());
+        }
+        return false;
+    }
+    
+    public static boolean isPublicMethod(IMethod method) {
+        try {
+            return Flags.isPublic(method.getFlags()) && !method.isConstructor() && !method.isMainMethod();
+        } catch (JavaModelException jme) {
+            JAXWSCorePlugin.log(jme.getStatus());
+        }
+        return false;
+    }
+
+    public static IStatus validateJavaTypeName(String projectName, String compilationUnitName) {
+        IJavaProject javaProject = JDTUtils.getJavaProject(projectName);
+        String sourceLevel = javaProject.getOption(JavaCore.COMPILER_SOURCE, true);
+        String complianceLevel = javaProject.getOption(JavaCore.COMPILER_COMPLIANCE, true);
+        return JavaConventions.validateJavaTypeName(compilationUnitName, sourceLevel, complianceLevel);
+    }
+
+    public static IStatus validatePackageName(String projectName, String packageName) {
+        IJavaProject javaProject = JDTUtils.getJavaProject(projectName);
+        String sourceLevel = javaProject.getOption(JavaCore.COMPILER_SOURCE, true);
+        String complianceLevel = javaProject.getOption(JavaCore.COMPILER_COMPLIANCE, true);
+        return JavaConventions.validatePackageName(packageName, sourceLevel, complianceLevel);
+    }
+    
+	public static ICompilationUnit getCompilationUnitFromFile(IFile file) {
+		IProject project = file.getProject();
+		try {
+			if (project.hasNature(JavaCore.NATURE_ID)) {
+				IJavaProject javaProject = JavaCore.create(project);
+				IPackageFragmentRoot[] packageFragmentRoots = javaProject.getPackageFragmentRoots();
+				for (IPackageFragmentRoot packageFragmentRoot : packageFragmentRoots) {
+					if (packageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE) {
+						IJavaElement[] packageFragments = packageFragmentRoot.getChildren();
+						for (IJavaElement javaElement : packageFragments) {
+							if (javaElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
+								IPackageFragment packageFragment = (IPackageFragment)javaElement;
+								ICompilationUnit[] compilationUnits = packageFragment.getCompilationUnits();
+								for (ICompilationUnit compilationUnit : compilationUnits) {
+									if (compilationUnit.getPath().equals(file.getFullPath())) {
+										return compilationUnit;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		} catch (JavaModelException jme) {
+			JAXWSCorePlugin.log(jme.getStatus());
+		} catch (CoreException ce) {
+			JAXWSCorePlugin.log(ce.getStatus());
+		}
+		return null;
+	}
+	
+    public static CompilationUnit getCompilationUnit(ICompilationUnit source) {
+        ASTParser parser = ASTParser.newParser(AST.JLS3);
+        parser.setSource(source);
+        CompilationUnit compilationUnit = (CompilationUnit) parser.createAST(new NullProgressMonitor());
+        compilationUnit.recordModifications();
+        
+        return compilationUnit;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static SingleVariableDeclaration getMethodParameter(IMethod method, int offset) {
+        CompilationUnit compilationUnit = JDTUtils.getCompilationUnit(method.getCompilationUnit());
+        IType type = method.getDeclaringType();
+        List<AbstractTypeDeclaration> types = compilationUnit.types();
+        for (AbstractTypeDeclaration abstractTypeDeclaration : types) {
+            if (abstractTypeDeclaration.getName().getIdentifier().equals(type.getElementName())) {
+                String methodToAnnotateName = method.getElementName();
+                List<BodyDeclaration> bodyDeclarations = getBodyDeclarationsForType(abstractTypeDeclaration);
+                for (BodyDeclaration bodyDeclaration : bodyDeclarations) {
+                    if (bodyDeclaration instanceof MethodDeclaration) {
+                        MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
+                        if (methodDeclaration.getName().getIdentifier().equals(methodToAnnotateName)) {
+                            List<SingleVariableDeclaration> parameters = methodDeclaration.parameters();
+                            for (SingleVariableDeclaration parameter : parameters) {
+                                int parameterStartPosition = parameter.getStartPosition();
+                                int parameterLength = parameter.getLength();
+                                if (offset >= parameterStartPosition
+                                        && offset <= parameterStartPosition + parameterLength) {
+                                    return parameter;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static List<BodyDeclaration> getBodyDeclarationsForType(
+            AbstractTypeDeclaration abstractTypeDeclaration) {
+        if (abstractTypeDeclaration instanceof TypeDeclaration) {
+            TypeDeclaration typeDeclaration = (TypeDeclaration) abstractTypeDeclaration;
+            return typeDeclaration.bodyDeclarations();
+        }
+        if (abstractTypeDeclaration instanceof EnumDeclaration) {
+            EnumDeclaration enumDeclaration = (EnumDeclaration) abstractTypeDeclaration;
+            return enumDeclaration.bodyDeclarations();
+        }
+        if (abstractTypeDeclaration instanceof AnnotationTypeDeclaration) {
+            AnnotationTypeDeclaration annotationTypeDeclaration = 
+                (AnnotationTypeDeclaration) abstractTypeDeclaration;
+            return annotationTypeDeclaration.bodyDeclarations();
+        }
+        return Collections.emptyList();
+    }  
+}