Jaxb enum validation

15 files changed, 306 insertions, 42 deletions

diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/property_files/jaxb_validation.properties b/jaxb/plugins/org.eclipse.jpt.jaxb.core/property_files/jaxb_validation.properties
index 8f25ce2cc2..8d38751f4a 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/property_files/jaxb_validation.properties
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/property_files/jaxb_validation.properties
@@ -17,11 +17,16 @@ PACKAGE_XML_JAVA_TYPE_ADAPTER_TYPE_NOT_SPECIFIED = The type must be specified fo
 XML_SCHEMA__MISMATCHED_ATTRIBUTE_FORM_DEFAULT = The attribute form default conflicts with what is specified on the schema
 XML_SCHEMA__MISMATCHED_ELEMENT_FORM_DEFAULT = The element form default conflicts with what is specified on the schema
 
+XML_ENUM__NON_SIMPLE_SCHEMA_TYPE = The type ''{0}'' must be associated with a simple schema type.
+
 XML_TYPE__UNMATCHING_NAMESPACE_FOR_ANONYMOUS_TYPE = The namespace for an anonymous type should not be different from its package
 XML_TYPE__DUPLICATE_PROP = Duplicate property ''{0}''.
 XML_TYPE__MISSING_PROP = Missing required property ''{0}''.
 XML_TYPE__NONEXISTENT_PROP = Nonexistent property ''{0}''.
 XML_TYPE__TRANSIENT_PROP = The property ''{0}'' is transient and should not be included in the property order.
+XML_TYPE__FACTORY_CLASS_IGNORED_FOR_ENUM = The factory class element is ignored for enums.
+XML_TYPE__FACTORY_METHOD_IGNORED_FOR_ENUM = The factory method element is ignored for enums.
+XML_TYPE__PROP_ORDER_IGNORED_FOR_ENUM = The prop order element is ignored for enums.
 
 XML_ROOT_ELEMENT_TYPE_CONFLICTS_WITH_XML_TYPE = The xml type of the element declaration with name ''{0}'' and namespace ''{1}'' conflicts with the xml type of the associated class
 
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbContextRoot.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbContextRoot.java
index a241a5b0cd..f203a01b64 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbContextRoot.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbContextRoot.java
@@ -102,6 +102,11 @@ public interface JaxbContextRoot
 	JaxbClassMapping getClassMapping(String typeName);
 	
 	
+	// ***** misc *****
+	
+	
+	
+	
 	// ***** validation *****
 	
 	/**
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbEnumMapping.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbEnumMapping.java
index 6dd9b362bd..68ce328a74 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbEnumMapping.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/context/JaxbEnumMapping.java
@@ -26,13 +26,26 @@ public interface JaxbEnumMapping
 	
 	// ***** XmlEnum.value *****
 	
-	String ENUM_TYPE_PROPERTY = "enumType"; //$NON-NLS-1$
+	/**
+	 * Return the type specified for the XmlEnum.value, or "java.lang.String" if unspecified
+	 */
+	String getXmlEnumValue();
 	
-	String getEnumType();
+	String SPECIFIED_XML_ENUM_VALUE_PROPERTY = "specifiedXmlEnum"; //$NON-NLS-1$
 	
-	void setEnumType(String enumType);
+	/**
+	 * Return the value of the XmlEnum.value element
+	 */
+	String getSpecifiedXmlEnumValue();
 	
-	String DEFAULT_ENUM_TYPE = "java.lang.String"; //$NON-NLS-1$
+	void setSpecifiedXmlEnumValue(String xmlEnumValue);
+	
+	/**
+	 * Return the value of the XmlEnum.value element, taking into consideration imports
+	 */
+	String getFullyQualifiedXmlEnumValue();
+	
+	String DEFAULT_XML_ENUM_VALUE = "java.lang.String"; //$NON-NLS-1$
 	
 	
 	// ***** enum constants *****
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/AbstractJaxbPlatformDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/AbstractJaxbPlatformDefinition.java
index 9201f74403..dd75e3a83e 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/AbstractJaxbPlatformDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/AbstractJaxbPlatformDefinition.java
@@ -10,6 +10,9 @@
 package org.eclipse.jpt.jaxb.core.internal;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import org.eclipse.jpt.common.core.resource.java.AnnotationDefinition;
 import org.eclipse.jpt.common.core.resource.java.NestableAnnotationDefinition;
 import org.eclipse.jpt.common.utility.internal.iterables.ArrayListIterable;
@@ -26,6 +29,8 @@ import org.eclipse.jpt.jaxb.core.platform.JaxbPlatformDefinition;
 public abstract class AbstractJaxbPlatformDefinition
 		implements JaxbPlatformDefinition {
 	
+	private Map<String, String> javaToSchemaTypes;
+	
 	private AnnotationDefinition[] annotationDefinitions;
 
 	private NestableAnnotationDefinition[] nestableAnnotationDefinitions;
@@ -47,6 +52,21 @@ public abstract class AbstractJaxbPlatformDefinition
 	}
 	
 	
+	// ***** platform-y things *****
+	
+	public String getSchemaTypeMapping(String javaTypeName) {
+		if (this.javaToSchemaTypes == null) {
+			 this.javaToSchemaTypes = new HashMap<String, String>();
+			 this.javaToSchemaTypes.putAll(buildJavaToSchemaTypes());
+		}
+		return this.javaToSchemaTypes.get(javaTypeName);
+	}
+	
+	protected Map<String, String> buildJavaToSchemaTypes() {
+		return Collections.EMPTY_MAP;
+	}
+	
+	
 	// ********** annotation definitions **********
 	
 	public AnnotationDefinition[] getAnnotationDefinitions() {
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/context/java/GenericJavaEnumMapping.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/context/java/GenericJavaEnumMapping.java
index ffec69e7ca..80f026ffb0 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/context/java/GenericJavaEnumMapping.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/context/java/GenericJavaEnumMapping.java
@@ -9,20 +9,36 @@
  *******************************************************************************/
 package org.eclipse.jpt.jaxb.core.internal.context.java;
 
+import java.util.List;
+import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.resource.java.JavaResourceEnum;
 import org.eclipse.jpt.common.core.resource.java.JavaResourceEnumConstant;
+import org.eclipse.jpt.common.core.utility.TextRange;
+import org.eclipse.jpt.common.utility.internal.CollectionTools;
+import org.eclipse.jpt.common.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.common.utility.internal.iterables.SingleElementIterable;
 import org.eclipse.jpt.jaxb.core.context.JaxbEnum;
 import org.eclipse.jpt.jaxb.core.context.JaxbEnumConstant;
 import org.eclipse.jpt.jaxb.core.context.JaxbEnumMapping;
+import org.eclipse.jpt.jaxb.core.context.JaxbType;
+import org.eclipse.jpt.jaxb.core.context.JaxbTypeMapping;
+import org.eclipse.jpt.jaxb.core.internal.validation.DefaultValidationMessages;
+import org.eclipse.jpt.jaxb.core.internal.validation.JaxbValidationMessages;
 import org.eclipse.jpt.jaxb.core.resource.java.JAXB;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlEnumAnnotation;
+import org.eclipse.jpt.jaxb.core.resource.java.XmlTypeAnnotation;
+import org.eclipse.jpt.jaxb.core.xsd.XsdSchema;
+import org.eclipse.jpt.jaxb.core.xsd.XsdTypeDefinition;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
+import org.eclipse.xsd.util.XSDUtil;
 
 
 public class GenericJavaEnumMapping
 		extends AbstractJavaTypeMapping
 		implements JaxbEnumMapping {
 	
-	protected String enumType;
+	protected String specifiedXmlEnumValue;
 
 	protected final EnumConstantContainer enumConstantContainer;
 
@@ -31,7 +47,7 @@ public class GenericJavaEnumMapping
 		super(parent);
 		this.enumConstantContainer = new EnumConstantContainer();
 		
-		initEnumType();
+		initXmlEnumValue();
 		initEnumConstants();
 	}
 	
@@ -47,7 +63,7 @@ public class GenericJavaEnumMapping
 	@Override
 	public void synchronizeWithResourceModel() {
 		super.synchronizeWithResourceModel();
-		syncEnumType();
+		syncXmlEnumValue();
 		syncEnumConstants();
 	}
 	
@@ -60,35 +76,45 @@ public class GenericJavaEnumMapping
 
 	// ***** XmlEnum.value *****
 	
-	public String getEnumType() {
-		return this.enumType;
+	public String getXmlEnumValue() {
+		return (this.specifiedXmlEnumValue != null) ? this.specifiedXmlEnumValue : DEFAULT_XML_ENUM_VALUE;
 	}
 	
-	public void setEnumType(String enumType) {
-		getXmlEnumAnnotation().setValue(enumType);
-		setEnumType_(enumType);	
+	public String getSpecifiedXmlEnumValue() {
+		return this.specifiedXmlEnumValue;
 	}
 	
-	protected void setEnumType_(String enumType) {
-		String old = this.enumType;
-		this.enumType = enumType;
-		firePropertyChanged(ENUM_TYPE_PROPERTY, old, enumType);
+	public void setSpecifiedXmlEnumValue(String xmlEnumValue) {
+		getXmlEnumAnnotation().setValue(xmlEnumValue);
+		setSpecifiedXmlEnumValue_(xmlEnumValue);	
+	}
+	
+	protected void setSpecifiedXmlEnumValue_(String xmlEnumValue) {
+		String old = this.specifiedXmlEnumValue;
+		this.specifiedXmlEnumValue = xmlEnumValue;
+		firePropertyChanged(SPECIFIED_XML_ENUM_VALUE_PROPERTY, old, xmlEnumValue);
+	}
+	
+	public String getFullyQualifiedXmlEnumValue() {
+		return (this.specifiedXmlEnumValue != null) ? 
+				getXmlEnumAnnotation().getFullyQualifiedValueClassName()
+				: DEFAULT_XML_ENUM_VALUE;
 	}
 	
 	protected XmlEnumAnnotation getXmlEnumAnnotation() {
 		return (XmlEnumAnnotation) getJavaResourceType().getNonNullAnnotation(JAXB.XML_ENUM);
 	}
 	
-	protected String getResourceEnumType() {
+	protected String getResourceXmlEnumValue() {
 		return getXmlEnumAnnotation().getValue();
 	}
 	
-	protected void initEnumType() {
-		this.enumType = getResourceEnumType();
+	protected void initXmlEnumValue() {
+		this.specifiedXmlEnumValue = getResourceXmlEnumValue();
 	}
 	
-	protected void syncEnumType() {
-		setEnumType_(getResourceEnumType());
+	protected void syncXmlEnumValue() {
+		setSpecifiedXmlEnumValue_(getResourceXmlEnumValue());
 	}
 	
 	
@@ -123,6 +149,109 @@ public class GenericJavaEnumMapping
 	}
 	
 	
+	// ***** misc *****
+	
+	@Override
+	protected Iterable<String> getNonTransientReferencedXmlTypeNames() {
+		if (this.specifiedXmlEnumValue != null) {
+			return new CompositeIterable<String>(
+					super.getNonTransientReferencedXmlTypeNames(),
+					new SingleElementIterable(getFullyQualifiedXmlEnumValue()));
+		}
+		return super.getNonTransientReferencedXmlTypeNames();
+	}
+	
+	
+	// ***** validation *****
+	
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		super.validate(messages, reporter, astRoot);
+		
+		validateXmlType(messages, reporter, astRoot);
+		validateXmlEnum(messages, reporter, astRoot);
+	}
+	
+	protected void validateXmlType(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		XmlTypeAnnotation annotation = getXmlTypeAnnotation();
+		
+		if (annotation.getFactoryClass() != null) {
+			messages.add(
+					DefaultValidationMessages.buildMessage(
+							IMessage.NORMAL_SEVERITY,
+							JaxbValidationMessages.XML_TYPE__FACTORY_CLASS_IGNORED_FOR_ENUM,
+							this,
+							annotation.getFactoryClassTextRange(astRoot)));
+		}
+		
+		if (annotation.getFactoryMethod() != null) {
+			messages.add(
+					DefaultValidationMessages.buildMessage(
+							IMessage.NORMAL_SEVERITY,
+							JaxbValidationMessages.XML_TYPE__FACTORY_METHOD_IGNORED_FOR_ENUM,
+							this,
+							annotation.getFactoryMethodTextRange(astRoot)));
+		}
+		
+		if (! CollectionTools.isEmpty(annotation.getPropOrder())) {
+			messages.add(
+					DefaultValidationMessages.buildMessage(
+							IMessage.NORMAL_SEVERITY,
+							JaxbValidationMessages.XML_TYPE__PROP_ORDER_IGNORED_FOR_ENUM,
+							this,
+							annotation.getPropOrderTextRange(astRoot)));
+		}
+	}
+	
+	protected void validateXmlEnum(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		String fqXmlEnumValue = getFullyQualifiedXmlEnumValue();
+		boolean nonSimpleSchemaType = false;
+		
+		JaxbType jaxbType = getContextRoot().getType(fqXmlEnumValue);
+		if (jaxbType != null) {
+			JaxbTypeMapping typeMapping = jaxbType.getMapping();
+			if (typeMapping != null) {
+				XsdTypeDefinition xsdType = typeMapping.getXsdTypeDefinition();
+				if (xsdType != null) {
+					nonSimpleSchemaType = xsdType.getKind() != XsdTypeDefinition.Kind.SIMPLE;
+				}
+			}
+		}
+		else {
+			String typeMapping = getJaxbProject().getPlatform().getDefinition().getSchemaTypeMapping(fqXmlEnumValue);
+			if (typeMapping == null) {
+				nonSimpleSchemaType = true;
+			}
+			else {
+				XsdSchema xsdSchema = getJaxbPackage().getXsdSchema();
+				if (xsdSchema != null) {
+					XsdTypeDefinition xsdType = xsdSchema.getTypeDefinition(XSDUtil.SCHEMA_FOR_SCHEMA_URI_2001, typeMapping);
+					if (xsdType == null) {
+						nonSimpleSchemaType = true;
+					}
+					else {
+						nonSimpleSchemaType = xsdType.getKind() != XsdTypeDefinition.Kind.SIMPLE;
+					}
+				}
+			}
+		}
+		
+		if (nonSimpleSchemaType) {
+			messages.add(
+					DefaultValidationMessages.buildMessage(
+							IMessage.HIGH_SEVERITY,
+							JaxbValidationMessages.XML_ENUM__NON_SIMPLE_SCHEMA_TYPE,
+							new String[] { fqXmlEnumValue },
+							this,
+							getXmlEnumValueTextRange(astRoot)));
+		}
+	}
+	
+	protected TextRange getXmlEnumValueTextRange(CompilationUnit astRoot) {
+		return getXmlEnumAnnotation().getValueTextRange(astRoot);
+	}
+	
+	
 	/**
 	 * enum constant container adapter
 	 */
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/jaxb21/GenericJaxb_2_1_PlatformDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/jaxb21/GenericJaxb_2_1_PlatformDefinition.java
index 379eaf87c5..e1a0351ca7 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/jaxb21/GenericJaxb_2_1_PlatformDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/jaxb21/GenericJaxb_2_1_PlatformDefinition.java
@@ -10,6 +10,8 @@
 package org.eclipse.jpt.jaxb.core.internal.jaxb21;
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jpt.common.core.JptCommonCorePlugin;
 import org.eclipse.jpt.common.core.JptResourceType;
@@ -95,6 +97,26 @@ public class GenericJaxb_2_1_PlatformDefinition
 	}
 	
 	@Override
+	protected Map<String, String> buildJavaToSchemaTypes() {
+		Map<String, String> map = new HashMap<String, String>();
+		map.put("java.lang.String", "string");
+		map.put("java.math.BigInteger", "integer");
+		map.put("java.math.BigDecimal", "decimal");
+		map.put("java.util.Calendar", "dateTime");
+		map.put("java.util.Date", "dateTime");
+		map.put("java.xml.namespace.QName", "QName");
+		map.put("java.net.URI", "string");
+		map.put("java.xml.datatype.XMLGregorianCalendar", "anySimpleType");
+		map.put("java.xml.datatype.Duration", "duration");
+		map.put("java.lang.Object", "anyType");
+		map.put("java.awt.Image", "base64Binary");
+		map.put("javax.activation.DataHandler", "base64Binary");
+		map.put("javax.xml.transform.Source", "base64Binary");
+		map.put("java.util.UUID", "string");
+		return map;
+	}
+	
+	@Override
 	protected JaxbResourceModelProvider[] buildResourceModelProviders() {
 		// order should not be important here
 		return new JaxbResourceModelProvider[] {
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/platform/JaxbPlatformImpl.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/platform/JaxbPlatformImpl.java
index 230f624811..978a21cb8f 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/platform/JaxbPlatformImpl.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/platform/JaxbPlatformImpl.java
@@ -49,6 +49,10 @@ public final class JaxbPlatformImpl
 		return this.platformDefinition.getDescription();
 	}
 	
+	public JaxbPlatformDefinition getDefinition() {
+		return this.platformDefinition;
+	}
+	
 	// ********** factory **********
 
 	public JaxbFactory getFactory() {
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/validation/JaxbValidationMessages.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/validation/JaxbValidationMessages.java
index 1a339e3659..e5136d72d6 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/validation/JaxbValidationMessages.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/internal/validation/JaxbValidationMessages.java
@@ -33,11 +33,16 @@ public interface JaxbValidationMessages {
 	
 	// validation on type
 	
+	String XML_ENUM__NON_SIMPLE_SCHEMA_TYPE = "XML_ENUM__NON_SIMPLE_SCHEMA_TYPE";
+	
 	String XML_TYPE__UNMATCHING_NAMESPACE_FOR_ANONYMOUS_TYPE = "XML_TYPE__UNMATCHING_NAMESPACE_FOR_ANONYMOUS_TYPE";
 	String XML_TYPE__DUPLICATE_PROP = "XML_TYPE__DUPLICATE_PROP";
 	String XML_TYPE__MISSING_PROP = "XML_TYPE__MISSING_PROP";
 	String XML_TYPE__NONEXISTENT_PROP = "XML_TYPE__NONEXISTENT_PROP";
 	String XML_TYPE__TRANSIENT_PROP = "XML_TYPE__TRANSIENT_PROP";
+	String XML_TYPE__FACTORY_CLASS_IGNORED_FOR_ENUM = "XML_TYPE__FACTORY_CLASS_IGNORED_FOR_ENUM";
+	String XML_TYPE__FACTORY_METHOD_IGNORED_FOR_ENUM = "XML_TYPE__FACTORY_METHOD_IGNORED_FOR_ENUM";
+	String XML_TYPE__PROP_ORDER_IGNORED_FOR_ENUM = "XML_TYPE__PROP_ORDER_IGNORED_FOR_ENUM";
 	
 	String XML_ROOT_ELEMENT_TYPE_CONFLICTS_WITH_XML_TYPE = "XML_ROOT_ELEMENT_TYPE_CONFLICTS_WITH_XML_TYPE";
 	
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatform.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatform.java
index 3602719a5f..0bd885ac84 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatform.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatform.java
@@ -33,6 +33,9 @@ public interface JaxbPlatform {
 	
 	JaxbPlatformDescription getDescription();
 	
+	JaxbPlatformDefinition getDefinition();
+	
+	
 	// ********** factory **********
 
 	/**
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatformDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatformDefinition.java
index 6ea6001fd8..c1ae7dc1c0 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatformDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/platform/JaxbPlatformDefinition.java
@@ -33,6 +33,14 @@ public interface JaxbPlatformDefinition {
 	
 	JaxbPlatformDescription getDescription();
 	
+	// ***** platform-y questions *****
+	
+	/**
+	 * Return the built in schema type name mapped by the given (fully qualified) java type name
+	 */
+	String getSchemaTypeMapping(String javaTypeName);
+	
+	
 	JaxbFactory getFactory();
 	
 	AnnotationDefinition[] getAnnotationDefinitions();
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdComplexTypeDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdComplexTypeDefinition.java
index c7f079265e..eb615067b6 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdComplexTypeDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdComplexTypeDefinition.java
@@ -29,6 +29,11 @@ public class XsdComplexTypeDefinition
 	
 	
 	@Override
+	public org.eclipse.jpt.jaxb.core.xsd.XsdTypeDefinition.Kind getKind() {
+		return Kind.COMPLEX;
+	}
+	
+	@Override
 	public XsdAttributeUse getAttribute(String namespace, String name) {
 		for (XsdAttributeUse attrUse : getAttributeUses(namespace)) {
 			if (attrUse.getXSDComponent().getAttributeDeclaration().getName().equals(name)) {
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdSimpleTypeDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdSimpleTypeDefinition.java
index 93aafa4680..f8d1eb41b6 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdSimpleTypeDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdSimpleTypeDefinition.java
@@ -23,6 +23,11 @@ public class XsdSimpleTypeDefinition
 	
 	
 	@Override
+	public org.eclipse.jpt.jaxb.core.xsd.XsdTypeDefinition.Kind getKind() {
+		return Kind.SIMPLE;
+	}
+	
+	@Override
 	public XsdAttributeUse getAttribute(String namespace, String name) {
 		// simple types have no attributes
 		return null;
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdTypeDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdTypeDefinition.java
index debb3c66b9..8cbea7ed2a 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdTypeDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.core/src/org/eclipse/jpt/jaxb/core/xsd/XsdTypeDefinition.java
@@ -25,6 +25,8 @@ public abstract class XsdTypeDefinition<A extends XSDTypeDefinition>
 		return getXSDComponent().getName();
 	}
 	
+	public abstract Kind getKind();
+	
 	public abstract XsdAttributeUse getAttribute(String namespace, String name);
 	
 	public abstract Iterable<String> getAttributeNameProposals(String namespace, Filter<String> filter);
@@ -40,4 +42,18 @@ public abstract class XsdTypeDefinition<A extends XSDTypeDefinition>
 	}
 	
 	public abstract Iterable getElementNameProposals(String namespace, Filter<String> filter, boolean recurseChildren);
+	
+	
+	public enum Kind {
+		
+		/**
+		 * An {@link XsdTypeDefinition} of SIMPLE {@link Kind} may safely be cast to an {@link XsdSimpleTypeDefinition}
+		 */
+		SIMPLE,
+		
+		/**
+		 * An {@link XsdTypeDefinition} of COMPLEX {@link Kind} may safely be cast to an {@link XsdComplexTypeDefinition}
+		 */
+		COMPLEX;
+	}
 }
diff --git a/jaxb/plugins/org.eclipse.jpt.jaxb.eclipselink.core/src/org/eclipse/jpt/jaxb/eclipselink/core/internal/AbstractELJaxbPlatformDefinition.java b/jaxb/plugins/org.eclipse.jpt.jaxb.eclipselink.core/src/org/eclipse/jpt/jaxb/eclipselink/core/internal/AbstractELJaxbPlatformDefinition.java
index 965951125e..5e4365cd41 100644
--- a/jaxb/plugins/org.eclipse.jpt.jaxb.eclipselink.core/src/org/eclipse/jpt/jaxb/eclipselink/core/internal/AbstractELJaxbPlatformDefinition.java
+++ b/jaxb/plugins/org.eclipse.jpt.jaxb.eclipselink.core/src/org/eclipse/jpt/jaxb/eclipselink/core/internal/AbstractELJaxbPlatformDefinition.java
@@ -9,6 +9,8 @@
  *******************************************************************************/
 package org.eclipse.jpt.jaxb.eclipselink.core.internal;
 
+import java.util.HashMap;
+import java.util.Map;
 import org.eclipse.jpt.jaxb.core.internal.AbstractJaxbPlatformDefinition;
 import org.eclipse.jpt.jaxb.core.platform.JaxbPlatformDefinition;
 
@@ -22,4 +24,20 @@ public abstract class AbstractELJaxbPlatformDefinition
 	
 	
 	protected abstract JaxbPlatformDefinition getGenericJaxbPlatformDefinition();
+	
+	
+	@Override
+	public String getSchemaTypeMapping(String javaTypeName) {
+		String mapping = getGenericJaxbPlatformDefinition().getSchemaTypeMapping(javaTypeName);
+		return (mapping != null) ? mapping : super.getSchemaTypeMapping(javaTypeName);
+	}
+	
+	@Override
+	protected Map<String, String> buildJavaToSchemaTypes() {
+		Map<String, String> map = new HashMap<String, String>();
+		map.put("java.sql.Date", "date");
+		map.put("java.sql.Time", "time");
+		map.put("java.sql.Timestamp", "dateTime");
+		return map;
+	}
 }
diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaEnumMappingTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaEnumMappingTests.java
index bcb23fbab1..9b39ca4e72 100644
--- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaEnumMappingTests.java
+++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaEnumMappingTests.java
@@ -247,50 +247,55 @@ public class GenericJavaEnumMappingTests
 		assertNull(enumMapping.getXmlRootElement());
 	}
 
-	public void testModifyEnumType() throws Exception {
+	public void testModifyXmlEnumValue() throws Exception {
 		createEnumWithXmlType();
 		
 		JaxbEnum jaxbEnum = (JaxbEnum) CollectionTools.get(getContextRoot().getTypes(), 0);
 		JaxbEnumMapping enumMapping = jaxbEnum.getMapping();
 		JavaResourceEnum resourceEnum = jaxbEnum.getJavaResourceType();
 		
-		assertNull(enumMapping.getEnumType());
+		assertNull(enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals(JaxbEnumMapping.DEFAULT_XML_ENUM_VALUE, enumMapping.getXmlEnumValue());
 		
-		enumMapping.setEnumType("Integer");
+		enumMapping.setSpecifiedXmlEnumValue("Integer");
 		XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) resourceEnum.getAnnotation(JAXB.XML_ENUM);
 		assertEquals("Integer", xmlEnumAnnotation.getValue());
-		assertEquals("Integer", enumMapping.getEnumType());
+		assertEquals("Integer", enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals("Integer", enumMapping.getXmlEnumValue());
 		
-		enumMapping.setEnumType(null);
+		enumMapping.setSpecifiedXmlEnumValue(null);
 		xmlEnumAnnotation = (XmlEnumAnnotation) resourceEnum.getAnnotation(JAXB.XML_ENUM);
-		assertNull(xmlEnumAnnotation.getValue());
-		assertNull(enumMapping.getEnumType());
-	
+		assertNull(enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals(JaxbEnumMapping.DEFAULT_XML_ENUM_VALUE, enumMapping.getXmlEnumValue());
+		
 		resourceEnum.addAnnotation(JAXB.XML_TYPE);
 		resourceEnum.removeAnnotation(JAXB.XML_ENUM);
 		enumMapping = ((JaxbEnum) CollectionTools.get(getContextRoot().getTypes(), 0)).getMapping();
-		assertNull(enumMapping.getEnumType());
+		assertNull(enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals(JaxbEnumMapping.DEFAULT_XML_ENUM_VALUE, enumMapping.getXmlEnumValue());
 	}
 	
-	public void testUpdateEnumType() throws Exception {
+	public void testUpdateXmlEnumValue() throws Exception {
 		createEnumWithXmlType();
 		
 		JaxbEnum jaxbEnum = (JaxbEnum) CollectionTools.get(getContextRoot().getTypes(), 0);
 		JaxbEnumMapping enumMapping = jaxbEnum.getMapping();
 		JavaResourceEnum resourceEnum = jaxbEnum.getJavaResourceType();
 		
-		assertNull(enumMapping.getEnumType());
+		assertNull(enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals(JaxbEnumMapping.DEFAULT_XML_ENUM_VALUE, enumMapping.getXmlEnumValue());
 		
-		//add a factoryClass member value pair
 		AnnotatedElement annotatedElement = this.annotatedElement(resourceEnum);
-		annotatedElement.edit(new Member.Editor() {
-			public void edit(ModifiedDeclaration declaration) {
-				GenericJavaEnumMappingTests.this.addMarkerAnnotation(declaration.getDeclaration(), JAXB.XML_ENUM);
-				GenericJavaEnumMappingTests.this.addXmlEnumTypeMemberValuePair(declaration, JAXB.XML_ENUM__VALUE, "String");
-			}
-		});
-		assertEquals("String", enumMapping.getEnumType());
-
+		annotatedElement.edit(
+				new Member.Editor() {
+					public void edit(ModifiedDeclaration declaration) {
+						GenericJavaEnumMappingTests.this.addMarkerAnnotation(declaration.getDeclaration(), JAXB.XML_ENUM);
+						GenericJavaEnumMappingTests.this.addXmlEnumTypeMemberValuePair(declaration, JAXB.XML_ENUM__VALUE, "String");
+					}
+				});
+		assertEquals("String", enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals("String", enumMapping.getXmlEnumValue());
+		
 		//remove the factoryClass member value pair
 		annotatedElement.edit(new Member.Editor() {
 			public void edit(ModifiedDeclaration declaration) {
@@ -298,7 +303,8 @@ public class GenericJavaEnumMappingTests
 				GenericJavaEnumMappingTests.this.values(xmlEnumAnnotation).remove(0);
 			}
 		});
-		assertNull(enumMapping.getEnumType());
+		assertNull(enumMapping.getSpecifiedXmlEnumValue());
+		assertEquals(JaxbEnumMapping.DEFAULT_XML_ENUM_VALUE, enumMapping.getXmlEnumValue());
 	}
 
 	public void testUpdateEnumConstants() throws Exception {