use of org.eclipse.persistence.internal.oxm.schema.model.SimpleType in project eclipselink by eclipse-ee4j.
the class SchemaGenerator method buildSchemaComponentsForXPath.
/**
* This method will build element/complexType/typedefparticle components for a given xml-path,
* and return an XmlPathResult instance containg the sequence that the target should be added
* to, as well as the current schema - which could be different than the working schema used
* before calling this method in the case of a prefixed path element from a different namespace.
* Regarding the path 'target', if the xml-path was "contact-info/address/street", "street"
* would be the target. In this case the sequence containing the "address" element would be
* set in the XmlPathResult to be returned.
*
* The exception case is an 'any', where we want to process the last path element before
* returning - this is necessary due to the fact that an Any will be added to the sequence
* in place of the last path element by the calling method.
*/
private AddToSchemaResult buildSchemaComponentsForXPath(XPathFragment frag, AddToSchemaResult xpr, boolean isChoice, Property next) {
boolean isAny = next.isAny() || next.isAnyAttribute();
TypeDefParticle currentParticle = xpr.particle;
Schema workingSchema = xpr.schema;
// each nested choice on a collection will be unbounded
boolean isUnbounded = false;
if (currentParticle != null) {
isUnbounded = (currentParticle.getMaxOccurs() != null && currentParticle.getMaxOccurs() == Occurs.UNBOUNDED);
}
// don't process the last frag; that will be handled by the calling method if necessary
// note that we may need to process the last frag if it has a namespace or is an 'any'
boolean lastFrag = (frag.getNextFragment() == null || frag.getNextFragment().nameIsText());
// if the element is already in the sequence we don't want the calling method to add a second one
if (lastFrag && (elementExistsInParticle(frag.getLocalName(), frag.getShortName(), currentParticle) != null)) {
xpr.particle = null;
return xpr;
}
// if the current element exists, use it; otherwise create a new one
Element currentElement = elementExistsInParticle(frag.getLocalName(), frag.getShortName(), currentParticle);
boolean currentElementExists = (currentElement != null);
if (!currentElementExists) {
currentElement = new Element();
// don't set the element name yet, as it may end up being a ref
ComplexType cType = new ComplexType();
TypeDefParticle particle = null;
if (isChoice) {
particle = new Choice();
if (isUnbounded) {
particle.setMaxOccurs(Occurs.UNBOUNDED);
}
} else {
XPathFragment nextFragment = frag.getNextFragment();
if (frag.containsIndex() || frag.getPredicate() != null || (!next.isXmlList() && null != nextFragment && nextFragment.isAttribute() && helper.isCollectionType(next.getType()))) {
currentElement.setMaxOccurs(Occurs.UNBOUNDED);
}
particle = new Sequence();
}
cType.setTypeDefParticle(particle);
currentElement.setComplexType(cType);
} else {
// if the current element already exists, we may need to change it's type
XPathFragment nextFrag = frag.getNextFragment();
if (nextFrag != null && nextFrag.isAttribute()) {
if (currentElement.getType() != null && currentElement.getComplexType() == null) {
// there's already a text mapping to this element, so
// attributes can be added by making it complex with
// simple content.
SimpleType type = currentElement.getSimpleType();
if (type != null) {
ComplexType cType = new ComplexType();
cType.setSimpleContent(new SimpleContent());
Extension extension = new Extension();
extension.setBaseType(type.getRestriction().getBaseType());
cType.getSimpleContent().setExtension(extension);
currentElement.setSimpleType(null);
currentElement.setComplexType(cType);
} else {
String eType = currentElement.getType();
ComplexType cType = new ComplexType();
SimpleContent sContent = new SimpleContent();
Extension extension = new Extension();
extension.setBaseType(eType);
sContent.setExtension(extension);
cType.setSimpleContent(sContent);
currentElement.setType(null);
currentElement.setComplexType(cType);
}
}
}
}
// may need to create a ref, depending on the namespace
Element globalElement = null;
String fragUri = frag.getNamespaceURI();
if (fragUri != null) {
Schema fragSchema = getSchemaForNamespace(fragUri);
String targetNS = workingSchema.getTargetNamespace();
// handle Attribute case
if (frag.isAttribute()) {
if (fragSchema == null || (fragSchema.isAttributeFormDefault() && !fragUri.equals(targetNS)) || (!fragSchema.isAttributeFormDefault() && fragUri.length() > 0)) {
// if fragSchema is null, just generate the ref
if (fragSchema != null) {
Attribute globalAttribute = null;
globalAttribute = fragSchema.getTopLevelAttributes().get(frag.getLocalName());
if (globalAttribute == null) {
globalAttribute = createGlobalAttribute(frag, workingSchema, fragSchema, next);
}
} else {
// may need to add an import
addImportIfRequired(workingSchema, null, fragUri);
}
// add the attribute ref to the current element
String attributeRefName;
if (fragUri.equals(targetNS)) {
String prefix = fragSchema.getNamespaceResolver().resolveNamespaceURI(fragUri);
attributeRefName = prefix + COLON + frag.getLocalName();
} else {
attributeRefName = frag.getShortName();
}
TypeDefParticleOwner type;
if (currentParticle != null) {
type = currentParticle.getOwner();
} else {
type = xpr.simpleContentType;
}
if (type instanceof ComplexType) {
createRefAttribute(attributeRefName, (ComplexType) type);
}
// set the frag's schema as it may be different than the current schema
xpr.schema = fragSchema;
// ref case - indicate to the calling method that there's nothing to do
xpr.particle = null;
}
// since we are dealing with an attribute, we are on the last fragment; return
return xpr;
}
// here we are dealing with an Element
if ((fragSchema.isElementFormDefault() && !fragUri.equals(targetNS)) || (!fragSchema.isElementFormDefault() && fragUri.length() > 0)) {
// must generate a global element and create a reference to it
// if the global element exists, use it; otherwise create a new one
globalElement = fragSchema.getTopLevelElements().get(frag.getLocalName());
if (globalElement == null) {
globalElement = createGlobalElement(frag, workingSchema, fragSchema, isChoice, isUnbounded, next, (lastFrag && !isAny));
}
// if the current element doesn't exist set a ref and add it to the sequence
if (!currentElementExists) {
// use prefix from the working schema's resolver - add prefix/uri pair if necessary
String fragPrefix = workingSchema.getNamespaceResolver().resolveNamespaceURI(fragUri);
if (fragPrefix == null) {
fragPrefix = workingSchema.getNamespaceResolver().generatePrefix(frag.getPrefix());
workingSchema.getNamespaceResolver().put(fragPrefix, fragUri);
}
currentElement = createRefElement(fragPrefix + COLON + frag.getLocalName(), currentParticle);
if (frag.containsIndex() || frag.getPredicate() != null || helper.isCollectionType(next.getType())) {
currentElement.setMaxOccurs(Occurs.UNBOUNDED);
}
currentElementExists = true;
}
// set the frag's schema as it may be different than the current schema
xpr.schema = fragSchema;
// at this point, if we are dealing with the last fragment we will need to return
if (lastFrag) {
// add a second one...unless we're dealing with an 'any'
if (isAny) {
// set the particle that the 'any' will be added to by the calling method
xpr.particle = globalElement.getComplexType().getTypeDefParticle();
return xpr;
}
// ref case - indicate to the calling method that there's nothing to do
xpr.particle = null;
return xpr;
}
// make the global element current
currentElement = globalElement;
}
}
if (!lastFrag || (lastFrag && isAny)) {
// if we didn't process a global element, and the current element isn't already in the sequence, add it
if (!currentElementExists && globalElement == null) {
currentElement.setName(frag.getLocalName());
Integer minOccurs = next.getMinOccurs();
if (minOccurs != null)
currentElement.setMinOccurs(String.valueOf(minOccurs));
else
currentElement.setMinOccurs(Occurs.ZERO);
currentParticle.addElement(currentElement);
}
// set the correct particle to use/return
if (currentElement.getComplexType() != null) {
if (currentElement.getComplexType().getTypeDefParticle() == null) {
// complexType with simple-content
xpr.simpleContentType = currentElement.getComplexType();
xpr.particle = null;
} else {
xpr.particle = currentElement.getComplexType().getTypeDefParticle();
}
} else {
// If there's no complex type, we're building the path through an element with
// a simple type. In order to build the path through this
// element, switch to a complex type with simple content.
SimpleType type = currentElement.getSimpleType();
if (type != null) {
ComplexType cType = new ComplexType();
cType.setSimpleContent(new SimpleContent());
Extension extension = new Extension();
extension.setBaseType(type.getRestriction().getBaseType());
cType.getSimpleContent().setExtension(extension);
currentElement.setSimpleType(null);
currentElement.setComplexType(cType);
xpr.particle = null;
xpr.simpleContentType = cType;
} else {
String eType = currentElement.getType();
ComplexType cType = new ComplexType();
SimpleContent sContent = new SimpleContent();
Extension extension = new Extension();
extension.setBaseType(eType);
sContent.setExtension(extension);
cType.setSimpleContent(sContent);
currentElement.setType(null);
currentElement.setComplexType(cType);
xpr.particle = null;
xpr.simpleContentType = cType;
}
}
}
// if we're on the last fragment, we're done
if (lastFrag) {
return xpr;
}
// call back into this method to process the next path element
return buildSchemaComponentsForXPath(frag.getNextFragment(), xpr, isChoice, next);
}
use of org.eclipse.persistence.internal.oxm.schema.model.SimpleType in project eclipselink by eclipse-ee4j.
the class SchemaGenerator method buildAttribute.
/**
* Build an Attribute based on a given Property.
*
* @param property the Property used to build the Attribute
* @param schema the schema currently being generated
*/
private Attribute buildAttribute(Property property, Schema schema) {
Attribute attribute = new Attribute();
QName attributeName = property.getSchemaName();
attribute.setName(attributeName.getLocalPart());
if (property.isRequired()) {
attribute.setUse(Attribute.REQUIRED);
}
String fixedValue = property.getFixedValue();
if (fixedValue != null) {
attribute.setFixed(fixedValue);
}
// Check to see if it's a collection
TypeInfo info = typeInfo.get(property.getActualType().getQualifiedName());
String typeName = getTypeNameForComponent(property, schema, property.getActualType(), attribute, false);
if (isCollectionType(property)) {
if (!property.isXmlList() && null != property.getXmlPath() && property.getXmlPath().contains("/")) {
attribute.setType(typeName);
} else {
// assume XmlList for an attribute collection
SimpleType localType = new SimpleType();
org.eclipse.persistence.internal.oxm.schema.model.List list = new org.eclipse.persistence.internal.oxm.schema.model.List();
list.setItemType(typeName);
localType.setList(list);
attribute.setSimpleType(localType);
}
} else {
// may need to qualify the type
if (typeName != null && !typeName.contains(COLON)) {
if (info.getSchema() == schema) {
String uri = schema.getTargetNamespace();
if (uri == null) {
uri = EMPTY_STRING;
}
String prefix = getPrefixForNamespace(schema, uri);
if (prefix != null) {
typeName = prefix + COLON + typeName;
}
}
}
attribute.setType(typeName);
}
return attribute;
}
use of org.eclipse.persistence.internal.oxm.schema.model.SimpleType in project eclipselink by eclipse-ee4j.
the class SchemaGenerator method buildElement.
/**
* Build an Element based on a given Property.
*
* @param property the Property used to build the Element
* @param isAll true if the Element will be added to an All structure
* @param schema the schema currently being built
* @param typeInfo the TypeInfo that owns the given Property
*/
private Element buildElement(Property property, boolean isAll, Schema schema, TypeInfo typeInfo) {
Element element = new Element();
// handle nillable
if (property.shouldSetNillable()) {
if (property.isNotNullAnnotated())
throw BeanValidationException.notNullAndNillable(property.getPropertyName());
element.setNillable(true);
}
// handle defaultValue
if (property.isSetDefaultValue()) {
element.setDefaultValue(property.getDefaultValue());
}
// handle mime-type
if (property.getMimeType() != null) {
element.getAttributesMap().put(Constants.EXPECTED_CONTENT_TYPES_QNAME, property.getMimeType());
}
QName elementName = property.getSchemaName();
String elementNamespace = elementName.getNamespaceURI();
String lookupNamespace = schema.getTargetNamespace();
if (lookupNamespace == null) {
lookupNamespace = EMPTY_STRING;
}
NamespaceInfo namespaceInfo = getNamespaceInfoForNamespace(lookupNamespace, getPackageName(typeInfo));
boolean isElementFormQualified = false;
if (namespaceInfo != null) {
isElementFormQualified = namespaceInfo.isElementFormQualified();
}
// handle element reference
boolean addRef = shouldAddRefAndSetForm(element, elementNamespace, lookupNamespace, isElementFormQualified, true);
if (addRef) {
schema = this.getSchemaForNamespace(elementNamespace);
}
JavaClass javaType = property.getActualType();
element.setName(elementName.getLocalPart());
String typeName = getTypeNameForComponent(property, schema, javaType, element, true);
if (property.getGenericType() != null) {
if (property.isXmlList()) {
SimpleType localSimpleType = new SimpleType();
org.eclipse.persistence.internal.oxm.schema.model.List list = new org.eclipse.persistence.internal.oxm.schema.model.List();
list.setItemType(typeName);
localSimpleType.setList(list);
element.setSimpleType(localSimpleType);
} else {
element.setMaxOccurs(Occurs.UNBOUNDED);
element.setType(typeName);
}
// handle map property
} else if (property.isMap()) {
addMapToSchema(property, element, schema, typeInfo);
} else {
element.setType(typeName);
}
// Set minOccurs based on the 'required' flag
Integer minOccurs = property.getMinOccurs();
if (minOccurs != null) {
element.setMinOccurs(String.valueOf(minOccurs));
} else {
element.setMinOccurs(property.isRequired() ? Occurs.ONE : Occurs.ZERO);
}
// Overwrite maxOccurs if it has been explicitly set on property.
Integer maxOccurs = property.getMaxOccurs();
if (maxOccurs != null)
element.setMaxOccurs(String.valueOf(maxOccurs));
if (facets) {
for (Facet facet : property.getFacets()) {
processFacet(element, facet);
}
}
return element;
}
use of org.eclipse.persistence.internal.oxm.schema.model.SimpleType in project eclipselink by eclipse-ee4j.
the class SchemaGenerator method processFacet.
private void processFacet(Element element, Facet facet) {
if (element.getSimpleType() == null)
element.setSimpleType(new SimpleType());
Restriction restriction = element.getSimpleType().getRestriction();
if (restriction == null) {
restriction = new Restriction(element.getType());
element.getSimpleType().setRestriction(restriction);
}
// Prevent error: "Cannot have both a 'type' attribute and an 'anonymous type' child".
element.setType(null);
facet.accept(FacetVisitorHolder.VISITOR, restriction);
}
use of org.eclipse.persistence.internal.oxm.schema.model.SimpleType in project eclipselink by eclipse-ee4j.
the class SDOTypesGenerator method preprocessGlobalTypes.
private void preprocessGlobalTypes(Schema schema) {
String targetNamespace = schema.getTargetNamespace();
// Global Complex Types
Collection<ComplexType> globalComplexTypes = schema.getTopLevelComplexTypes().values();
for (ComplexType globalComplexType : globalComplexTypes) {
QName xsdQName = new QName(targetNamespace, globalComplexType.getName());
SDOType sdoType = preprocessComplexType(globalComplexType, schema);
sdoType.setXsdType(xsdQName);
generatedTypesByXsdQName.put(xsdQName, sdoType);
}
// Global Simple Types
Collection<SimpleType> globalSimpleTypes = schema.getTopLevelSimpleTypes().values();
for (SimpleType globalSimpleType : globalSimpleTypes) {
QName xsdQName = new QName(targetNamespace, globalSimpleType.getName());
SDOType sdoType = preprocessSimpleType(globalSimpleType, schema);
sdoType.setXsdType(xsdQName);
generatedTypesByXsdQName.put(xsdQName, sdoType);
}
}
Aggregations