org.eclipse.xsd.util.XSDPrototypicalSchema
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
public class XSDPrototypicalSchema
The Sample Code to construct
the Purchase Order Schema
and the Prototype Schema
using the concrete APIs.
Additional examples include:
saving the Purchase Order Schema to a URI,
printing a schema loaded from a URI,
printing a component's element using Xerces,
creating a schema from an element,
tracing a resource set's loading behavior when loading a URI
cloning a component.
cross referencing.
| Field Summary | |
|---|---|
protected static XSDPrototypicalSchema |
instance
The one static instance. |
XSDSchema |
prototypeSchema
The Prototype Schema. |
XSDSchema |
purchaseOrderSchema
The Purchase Order Schema. |
protected java.lang.String |
someOtherSchemaURI
The value "http://www.example.com/SomeOtherSchema". |
XSDFactory |
xsdFactory
A cached XSDFactory. |
| Constructor Summary | |
|---|---|
XSDPrototypicalSchema()
Create the Prototype Schema and the Purchase Order Schema. |
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
protected static XSDPrototypicalSchema instance
public XSDFactory xsdFactory
public XSDSchema prototypeSchema
Prototype Schema.
public XSDSchema purchaseOrderSchema
Purchase Order Schema.
protected java.lang.String someOtherSchemaURI
"http://www.example.com/SomeOtherSchema".
| Constructor Detail |
|---|
public XSDPrototypicalSchema()
Prototype Schema and the Purchase Order Schema.
| Method Detail |
|---|
public static XSDPrototypicalSchema getInstance()
public static XSDSchema getPrototypicalSchema()
Prototype Schema instance.
public static XSDSchema getPurchaseOrderSchema()
Purchase Order Schema instance.
public XSDSchema initializePrototypeSchema()
{
// Create the schema, give it a target namespace, and set its form defaults.
//
prototypeSchema = xsdFactory.createXSDSchema();
prototypeSchema.setTargetNamespace("http://www.example.com/PrototypicalSchema");
prototypeSchema.setElementFormDefault(XSDForm.QUALIFIED_LITERAL);
prototypeSchema.setAttributeFormDefault(XSDForm.QUALIFIED_LITERAL);
// If you want schema tags and references to schema types to be qualified,
// which is recommend, this is the recommended qualifier.
//
prototypeSchema.setSchemaForSchemaQNamePrefix("xsd");
// Choose the prefix used for this schema's namespace,
// the schema for schema's namespace,
// and some other imported namespace.
//
Map qNamePrefixToNamespaceMap = prototypeSchema.getQNamePrefixToNamespaceMap();
qNamePrefixToNamespaceMap.put("PTS", prototypeSchema.getTargetNamespace());
qNamePrefixToNamespaceMap.put(prototypeSchema.getSchemaForSchemaQNamePrefix(), XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001);
qNamePrefixToNamespaceMap.put("EXT", someOtherSchemaURI);
// Initialize the other parts of this examples.
//
initializeSomeOtherImport();
initializeSimpleAttributeGroupDefinition();
initializeSimpleRecursiveModelGroupDefinition();
initializeSimpleRecursiveComplexTypeDefinition();
initializeSimpleRecursiveElementDeclaration();
initializeSimpleAttributeDeclaration();
initializeSimpleElementDeclarationWithAnonymousType();
initializeSimpleTypeDefinition();
initializeSimpleListTypeDefinition();
initializeSimpleUnionTypeDefinition();
initializeFancyListTypeDefinition();
initializeSimpleContentComplexTypeDefinition();
// This is the result that is produced.
//
// <?xml version="1.0" encoding="UTF-8"?>
// <xsd:schema attributeFormDefault="qualified"
// elementFormDefault="qualified"
// targetNamespace="http://www.example.com/PrototypicalSchema"
// xmlns:EXT="http://www.example.com/SomeOtherSchema"
// xmlns:PTS="http://www.example.com/PrototypicalSchema" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
// <xsd:import namespace="http://www.example.com/SomeOtherSchema" schemaLocation="http://www.example.com/SomeOtherSchema"/>
// <xsd:attributeGroup name="simpleAttributeGroupDefinition">
// <xsd:attribute default="defaultValue"
// name="simpleAttributeDeclarationGroupMember" type="EXT:someOtherTypeDefinition"/>
// </xsd:attributeGroup>
// <xsd:group name="simpleRecursiveModelGroupDefinition">
// <xsd:annotation/>
// <xsd:sequence>
// <xsd:element maxOccurs="unbounded" minOccurs="0" ref="PTS:simpleRecursiveElementDeclaration"/>
// <xsd:any namespace="##other" processContents="lax"/>
// </xsd:sequence>
// </xsd:group>
// <xsd:complexType abstract="false" block="#all" final="#all"
// mixed="true" name="SimpleRecursiveComplexTypeDefinition">
// <xsd:annotation>
// <xsd:appinfo source="http://www.example.com/appinfo"/>
// <xsd:documentation
// source="http://www.example.com/documentation">A simple
// recursive complex type definition.</xsd:documentation>
// </xsd:annotation>
// <xsd:group ref="PTS:simpleRecursiveModelGroupDefinition"/>
// <xsd:attribute ref="PTS:simpleAttributeDeclaration" use="optional"/>
// <xsd:attributeGroup ref="PTS:simpleAttributeGroupDefinition"/>
// <xsd:anyAttribute namespace="##other"/>
// </xsd:complexType>
// <xsd:element name="simpleRecursiveElementDeclaration" type="PTS:SimpleRecursiveComplexTypeDefinition">
// <xsd:annotation/>
// <xsd:unique name="unique">
// <xsd:selector xpath="simpleRecursiveElementDeclaration"/>
// <xsd:field xpath="simpleAttributeDeclarationGroupMember"/>
// </xsd:unique>
// <xsd:key name="key">
// <xsd:selector xpath="simpleRecursiveElementDeclaration"/>
// <xsd:field xpath="simpleAttributeDeclarationGroupMember"/>
// </xsd:key>
// <xsd:keyref name="keyref" refer="PTS:key">
// <xsd:selector xpath="simpleRecursiveElementDeclaration"/>
// <xsd:field xpath="simpleAttributeDeclaration"/>
// </xsd:keyref>
// </xsd:element>
// <xsd:attribute default="defaultValue"
// name="simpleAttributeDeclaration" type="EXT:someOtherTypeDefinition"/>
// <xsd:element fixed="12ab" name="simpleElementWithAnonymousType">
// <xsd:annotation/>
// <xsd:simpleType>
// <xsd:restriction base="xsd:string">
// <xsd:pattern value="\d\d.."/>
// </xsd:restriction>
// </xsd:simpleType>
// </xsd:element>
// <xsd:simpleType name="SimpleTypeDefinition">
// <xsd:annotation/>
// <xsd:restriction base="xsd:positiveInteger">
// <xsd:maxInclusive value="100"/>
// </xsd:restriction>
// </xsd:simpleType>
// <xsd:simpleType name="SimpleListTypeDefinition">
// <xsd:annotation/>
// <xsd:list itemType="xsd:integer"/>
// </xsd:simpleType>
// <xsd:simpleType name="SimpleUnionTypeDefinition">
// <xsd:annotation/>
// <xsd:union memberTypes="xsd:integer"/>
// </xsd:simpleType>
// <xsd:simpleType name="FancyListTypeDefinition">
// <xsd:restriction>
// <xsd:simpleType>
// <xsd:list>
// <xsd:simpleType>
// <xsd:union>
// <xsd:simpleType>
// <xsd:restriction base="xsd:string">
// <xsd:enumeration value="unknown"/>
// </xsd:restriction>
// </xsd:simpleType>
// <xsd:simpleType>
// <xsd:restriction base="xsd:decimal">
// <xsd:fractionDigits value="2"/>
// </xsd:restriction>
// </xsd:simpleType>
// </xsd:union>
// </xsd:simpleType>
// </xsd:list>
// </xsd:simpleType>
// <xsd:maxLength value="4"/>
// </xsd:restriction>
// </xsd:simpleType>
// <xsd:complexType name="SimpleContentComplexTypeDefinition">
// <xsd:annotation/>
// <xsd:simpleContent>
// <xsd:extension base="xsd:string">
// <xsd:attribute ref="PTS:simpleAttributeDeclaration" use="optional"/>
// </xsd:extension>
// </xsd:simpleContent>
// </xsd:complexType>
// </xsd:schema>
return prototypeSchema;
}
public void initializeSomeOtherImport()
{
// Create an import and set its namespace and schema location.
//
XSDImport someOtherImport = xsdFactory.createXSDImport();
someOtherImport.setNamespace(someOtherSchemaURI);
someOtherImport.setSchemaLocation(someOtherSchemaURI);
// Add the import to the schema contents.
//
prototypeSchema.getContents().add(someOtherImport);
// This is the result that is produced.
//
// <xsd:import namespace="http://www.example.com/SomeOtherSchema" schemaLocation="http://www.example.com/SomeOtherSchema"/>
}
public void initializeSimpleAttributeGroupDefinition()
{
// Create an attribute group definition and set it's name to simpleAttributeGroupDefinition.
//
XSDAttributeGroupDefinition simpleAttributeGroupDefinition = xsdFactory.createXSDAttributeGroupDefinition();
simpleAttributeGroupDefinition.setName("simpleAttributeGroupDefinition");
// Create an attribute, name it simpleAttributeDeclarationGroupMember,
// set it's type to someOtherTypeDefinition in some other schema.
// set its constraints to be default, set the lexical value of the constraint to be "defaultValue".
//
XSDAttributeDeclaration simpleAttributeDeclarationGroupMember = xsdFactory.createXSDAttributeDeclaration();
simpleAttributeDeclarationGroupMember.setName("simpleAttributeDeclarationGroupMember");
simpleAttributeDeclarationGroupMember.setTypeDefinition
(prototypeSchema.resolveSimpleTypeDefinition(someOtherSchemaURI, "someOtherTypeDefinition"));
// Create an attribute use to contain the attribute and add it the attribute group.
//
XSDAttributeUse simpleAttributeUseGroupMember = xsdFactory.createXSDAttributeUse();
simpleAttributeUseGroupMember.setContent(simpleAttributeDeclarationGroupMember);
simpleAttributeUseGroupMember.setConstraint(XSDConstraint.DEFAULT_LITERAL);
simpleAttributeUseGroupMember.setLexicalValue("defaultValue");
simpleAttributeGroupDefinition.getContents().add(simpleAttributeUseGroupMember);
// Add the attribute group to the schema.
//
prototypeSchema.getContents().add(simpleAttributeGroupDefinition);
// This is the result that is produced.
//
// <xsd:attributeGroup name="simpleAttributeGroupDefinition">
// <xsd:attribute default="defaultValue"
// name="simpleAttributeDeclarationGroupMember" type="EXT:someOtherTypeDefinition"/>
// </xsd:attributeGroup>
}
public void initializeSimpleRecursiveModelGroupDefinition()
{
// Create a model group definition and name it simpleRecursiveModelGroupDefinition.
//
XSDModelGroupDefinition simpleRecursiveModelGroupDefinition = xsdFactory.createXSDModelGroupDefinition();
simpleRecursiveModelGroupDefinition.setName("simpleRecursiveModelGroupDefinition");
// Create an annotation placeholder and add it to the model group definition.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleRecursiveModelGroupDefinition.setAnnotation(annotation);
// Create a sequence model group.
//
XSDModelGroup modelGroup = xsdFactory.createXSDModelGroup();
modelGroup.setCompositor(XSDCompositor.SEQUENCE_LITERAL);
// Create an element reference to the simpleRecursiveElementDeclaration of this schema.
//
XSDElementDeclaration simpleRecursiveElementDeclarationReference = xsdFactory.createXSDElementDeclaration();
simpleRecursiveElementDeclarationReference.setResolvedElementDeclaration
(prototypeSchema.resolveElementDeclaration("simpleRecursiveElementDeclaration"));
// Create a particle to hold the element and set it to be optional and unbounded.
//
XSDParticle simpleRecursiveElementParticle = xsdFactory.createXSDParticle();
simpleRecursiveElementParticle.setContent(simpleRecursiveElementDeclarationReference);
simpleRecursiveElementParticle.setMinOccurs(0);
simpleRecursiveElementParticle.setMaxOccurs(-1);
// Add the element particle to the model group.
//
modelGroup.getContents().add(simpleRecursiveElementParticle);
// Create an element wildcard, set the namespace constraint to be other, and the processing to be lax.
//
XSDWildcard elementWildcard = xsdFactory.createXSDWildcard();
elementWildcard.getLexicalNamespaceConstraint().add("##other");
elementWildcard.setProcessContents(XSDProcessContents.LAX_LITERAL);
// Create a particle to hold the wildcard.
//
XSDParticle wildcardParticle = xsdFactory.createXSDParticle();
wildcardParticle.setContent(elementWildcard);
// Add the wildcard particle to the model group.
//
modelGroup.getContents().add(wildcardParticle);
// Set the model group to be that of the simpleRecursiveModelGroupDefinition.
//
simpleRecursiveModelGroupDefinition.setModelGroup(modelGroup);
// Add simpleRecursiveModelGroupDefinition to the schema.
//
prototypeSchema.getContents().add(simpleRecursiveModelGroupDefinition);
// This is the result that is produced.
//
// <xsd:group name="simpleRecursiveModelGroupDefinition">
// <xsd:annotation/>
// <xsd:sequence>
// <xsd:element maxOccurs="unbounded" minOccurs="0" ref="PTS:simpleRecursiveElementDeclaration"/>
// <xsd:any namespace="##other" processContents="lax"/>
// </xsd:sequence>
// </xsd:group>
}
public void initializeSimpleRecursiveComplexTypeDefinition()
{
// Create a complex type definition and set its name to SimpleRecursiveComplexTypeDefinition.
// Set the complex type to be abstract, block all substitution, make it final in all regards,
// set it to be a restriction, and set it's content type to be mixed.
//
XSDComplexTypeDefinition simpleRecursiveComplexTypeDefinition = xsdFactory.createXSDComplexTypeDefinition();
simpleRecursiveComplexTypeDefinition.setName("SimpleRecursiveComplexTypeDefinition");
simpleRecursiveComplexTypeDefinition.setAbstract(false);
simpleRecursiveComplexTypeDefinition.getBlock().add(XSDProhibitedSubstitutions.ALL_LITERAL);
simpleRecursiveComplexTypeDefinition.getLexicalFinal().add(XSDComplexFinal.ALL_LITERAL);
simpleRecursiveComplexTypeDefinition.setDerivationMethod(XSDDerivationMethod.RESTRICTION_LITERAL);
simpleRecursiveComplexTypeDefinition.setMixed(true);
// Create an annotation placeholder and add it to the complex type
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleRecursiveComplexTypeDefinition.setAnnotation(annotation);
// Create a model group definition reference to simpleRecursiveModelGroupDefinition.
// Also create particle to hold it and set the particle to be the content of the complex type.
//
XSDModelGroupDefinition simpleRecursiveModelGroupDefinitionReference = xsdFactory.createXSDModelGroupDefinition();
simpleRecursiveModelGroupDefinitionReference.setResolvedModelGroupDefinition
(prototypeSchema.resolveModelGroupDefinition("simpleRecursiveModelGroupDefinition"));
XSDParticle modelGroupParticle = xsdFactory.createXSDParticle();
modelGroupParticle.setContent(simpleRecursiveModelGroupDefinitionReference);
simpleRecursiveComplexTypeDefinition.setContent(modelGroupParticle);
// Create an attribute reference to simpleAttributeDeclaration.
// Also create an attribute use to hold it, set the use to be optional,
// and add it to the complex type's attribute contents.
//
XSDAttributeDeclaration simpleAttributeDeclarationReference = xsdFactory.createXSDAttributeDeclaration();
simpleAttributeDeclarationReference.setResolvedAttributeDeclaration
(prototypeSchema.resolveAttributeDeclaration("simpleAttributeDeclaration"));
XSDAttributeUse simpleAttributeUse = xsdFactory.createXSDAttributeUse();
simpleAttributeUse.setContent(simpleAttributeDeclarationReference);
simpleAttributeUse.setUse(XSDAttributeUseCategory.OPTIONAL_LITERAL);
simpleRecursiveComplexTypeDefinition.getAttributeContents().add(simpleAttributeUse);
// Create an attribute group reference to simpleAttributeGroupDefinition.
// And add it to the complex type's attribute contents.
//
XSDAttributeGroupDefinition simpleAttributeGroupDefinitionReference = xsdFactory.createXSDAttributeGroupDefinition();
simpleAttributeGroupDefinitionReference.setResolvedAttributeGroupDefinition
(prototypeSchema.resolveAttributeGroupDefinition("simpleAttributeGroupDefinition"));
simpleRecursiveComplexTypeDefinition.getAttributeContents().add(simpleAttributeGroupDefinitionReference);
// Create an attribute wildcard and set its constraint to other.
// Also add it as the complex type's attribute wildcard.
//
XSDWildcard attributeWildcard = xsdFactory.createXSDWildcard();
attributeWildcard.getLexicalNamespaceConstraint().add("##other");
simpleRecursiveComplexTypeDefinition.setAttributeWildcardContent(attributeWildcard);
prototypeSchema.getContents().add(simpleRecursiveComplexTypeDefinition);
// Create an appinfo DOM element with the given sourceURI attribute.
// Also add the element as the annotation's child.
// NOTE
// Working with the contents of an annotation requires dropping down into the DOM model.
// This imposes the additional requirement that the annotation must be attached to a schema.
// It also has the effect of calling XSDConcreteComponent.updateElement(),
// if the schema does not have an element or document yet.
//
Element appinfo = annotation.createApplicationInformation("http://www.example.com/appinfo");
annotation.getElement().appendChild(appinfo);
// Create a documentation DOM element with the given sourceURI attribute.
// Also add the element as the annotation's child.
//
Element documentation = annotation.createUserInformation("http://www.example.com/documentation");
annotation.getElement().appendChild(documentation);
documentation.appendChild
(documentation.getOwnerDocument().createTextNode
("A simple recursive complex type definition."));
// This is the result that is produced.
//
// <xsd:complexType abstract="false" block="#all" final="#all"
// mixed="true" name="SimpleRecursiveComplexTypeDefinition">
// <xsd:annotation>
// <xsd:appinfo source="http://www.example.com/appinfo"/>
// <xsd:documentation
// source="http://www.example.com/documentation">A simple
// recursive complex type definition.</xsd:documentation>
// </xsd:annotation>
// <xsd:group ref="PTS:simpleRecursiveModelGroupDefinition"/>
// <xsd:attribute ref="PTS:simpleAttributeDeclaration" use="optional"/>
// <xsd:attributeGroup ref="PTS:simpleAttributeGroupDefinition"/>
// <xsd:anyAttribute namespace="##other"/>
// </xsd:complexType>
}
public void initializeSimpleRecursiveElementDeclaration()
{
// Create an element declaration and name it simpleRecursiveElementDeclaration.
//
XSDElementDeclaration simpleRecursiveElementDeclaration = xsdFactory.createXSDElementDeclaration();
simpleRecursiveElementDeclaration.setName("simpleRecursiveElementDeclaration");
// Create an annotation placeholder and set it to the element.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleRecursiveElementDeclaration.setAnnotation(annotation);
// Set the element type definition to complex SimpleRecursiveComplexTypeDefinition from this schema.
//
simpleRecursiveElementDeclaration.setTypeDefinition
(prototypeSchema.resolveComplexTypeDefinition("SimpleRecursiveComplexTypeDefinition"));
// Create a unique identity constraint called unique.
//
XSDIdentityConstraintDefinition unique = xsdFactory.createXSDIdentityConstraintDefinition();
unique.setIdentityConstraintCategory(XSDIdentityConstraintCategory.UNIQUE_LITERAL);
unique.setName("unique");
XSDXPathDefinition uniqueSelector = xsdFactory.createXSDXPathDefinition();
uniqueSelector.setVariety(XSDXPathVariety.SELECTOR_LITERAL);
uniqueSelector.setValue("simpleRecursiveElementDeclaration");
unique.setSelector(uniqueSelector);
XSDXPathDefinition uniqueField = xsdFactory.createXSDXPathDefinition();
uniqueField.setVariety(XSDXPathVariety.FIELD_LITERAL);
uniqueField.setValue("simpleAttributeDeclarationGroupMember");
unique.getFields().add(uniqueField);
simpleRecursiveElementDeclaration.getIdentityConstraintDefinitions().add(unique);
// Create a key identity constraint called key.
//
XSDIdentityConstraintDefinition key = xsdFactory.createXSDIdentityConstraintDefinition();
key.setIdentityConstraintCategory(XSDIdentityConstraintCategory.KEY_LITERAL);
key.setName("key");
XSDXPathDefinition keySelector = xsdFactory.createXSDXPathDefinition();
keySelector.setVariety(XSDXPathVariety.SELECTOR_LITERAL);
keySelector.setValue("simpleRecursiveElementDeclaration");
key.setSelector(keySelector);
XSDXPathDefinition keyField = xsdFactory.createXSDXPathDefinition();
keyField.setVariety(XSDXPathVariety.FIELD_LITERAL);
keyField.setValue("simpleAttributeDeclarationGroupMember");
key.getFields().add(keyField);
simpleRecursiveElementDeclaration.getIdentityConstraintDefinitions().add(key);
// Create a keyref identity constraint called keyref that references key.
//
XSDIdentityConstraintDefinition keyref = xsdFactory.createXSDIdentityConstraintDefinition();
keyref.setIdentityConstraintCategory(XSDIdentityConstraintCategory.KEYREF_LITERAL);
keyref.setName("keyref");
XSDXPathDefinition keyrefSelector = xsdFactory.createXSDXPathDefinition();
keyrefSelector.setVariety(XSDXPathVariety.SELECTOR_LITERAL);
keyrefSelector.setValue("simpleRecursiveElementDeclaration");
keyref.setSelector(keyrefSelector);
XSDXPathDefinition keyrefField = xsdFactory.createXSDXPathDefinition();
keyrefField.setVariety(XSDXPathVariety.FIELD_LITERAL);
keyrefField.setValue("simpleAttributeDeclaration");
keyref.setReferencedKey(key);
keyref.getFields().add(keyrefField);
simpleRecursiveElementDeclaration.getIdentityConstraintDefinitions().add(keyref);
// Add the element to the schema.
//
prototypeSchema.getContents().add(simpleRecursiveElementDeclaration);
// This is the result that is produced.
//
// <xsd:element name="simpleRecursiveElementDeclaration" type="PTS:SimpleRecursiveComplexTypeDefinition">
// <xsd:annotation/>
// <xsd:unique name="unique">
// <xsd:selector xpath="simpleRecursiveElementDeclaration"/>
// <xsd:field xpath="simpleAttributeDeclarationGroupMember"/>
// </xsd:unique>
// <xsd:key name="key">
// <xsd:selector xpath="simpleRecursiveElementDeclaration"/>
// <xsd:field xpath="simpleAttributeDeclarationGroupMember"/>
// </xsd:key>
// <xsd:keyref name="keyref" refer="PTS:key">
// <xsd:selector xpath="simpleRecursiveElementDeclaration"/>
// <xsd:field xpath="simpleAttributeDeclaration"/>
// </xsd:keyref>
// </xsd:element>
}
public void initializeSimpleAttributeDeclaration()
{
// Create an attribute declaration and set it's name to simpleAttributeDeclaration.
// Set it's type definition to be someOtherTypeDefinition in someOtherSchemaURI,
// and set the default constraint to "defaultValue".
//
XSDAttributeDeclaration simpleAttributeDeclaration = xsdFactory.createXSDAttributeDeclaration();
simpleAttributeDeclaration.setName("simpleAttributeDeclaration");
simpleAttributeDeclaration.setTypeDefinition
(prototypeSchema.resolveSimpleTypeDefinition(someOtherSchemaURI, "someOtherTypeDefinition"));
simpleAttributeDeclaration.setConstraint(XSDConstraint.DEFAULT_LITERAL);
simpleAttributeDeclaration.setLexicalValue("defaultValue");
// Add the attribute to the schema.
//
prototypeSchema.getContents().add(simpleAttributeDeclaration);
// This is the result that is produced.
//
// <xsd:attribute default="defaultValue"
// name="simpleAttributeDeclaration" type="EXT:someOtherTypeDefinition"/>
}
public void initializeSimpleElementDeclarationWithAnonymousType()
{
// Create an element declaration and set it's name to simpleElementWithAnonymousType.
//
XSDElementDeclaration simpleElementDeclarationWithAnonymousType = xsdFactory.createXSDElementDeclaration();
simpleElementDeclarationWithAnonymousType.setName("simpleElementWithAnonymousType");
// Create an annotation placeholder and add it to the element.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleElementDeclarationWithAnonymousType.setAnnotation(annotation);
// Create an anonymous simple type definition and set it's base type to the built-in string.
//
XSDSimpleTypeDefinition anonymousSimpleTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
anonymousSimpleTypeDefinition.setBaseTypeDefinition
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
// Create pattern facet.
// Set it to match two digits followed by any two characters.
// And add it to the anonymous type.
//
XSDPatternFacet xsdPatternFacet = xsdFactory.createXSDPatternFacet();
xsdPatternFacet.setLexicalValue("\\d\\d..");
anonymousSimpleTypeDefinition.getFacetContents().add(xsdPatternFacet);
// Set the element's annotation and anonymous type,
// and set the fixed constraint to "12ab".
//
simpleElementDeclarationWithAnonymousType.setAnnotation(annotation);
simpleElementDeclarationWithAnonymousType.setAnonymousTypeDefinition(anonymousSimpleTypeDefinition);
simpleElementDeclarationWithAnonymousType.setConstraint(XSDConstraint.FIXED_LITERAL);
simpleElementDeclarationWithAnonymousType.setLexicalValue("12ab");
// Add the element to the schema.
//
prototypeSchema.getContents().add(simpleElementDeclarationWithAnonymousType);
// This is the result that is produced.
//
// <xsd:element fixed="12ab" name="simpleElementWithAnonymousType">
// <xsd:annotation/>
// <xsd:simpleType>
// <xsd:restriction base="xsd:string">
// <xsd:pattern value="\d\d.."/>
// </xsd:restriction>
// </xsd:simpleType>
// </xsd:element>
}
public void initializeSimpleTypeDefinition()
{
// Create a simple type definition and set it's name to SimpleTypeDefinition.
// Also set it's base type to be the built-in positiveInteger.
//
XSDSimpleTypeDefinition simpleTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
simpleTypeDefinition.setName("SimpleTypeDefinition");
simpleTypeDefinition.setBaseTypeDefinition
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("positiveInteger"));
// Create an annotation placeholder and add it to the type.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleTypeDefinition.setAnnotation(annotation);
// Create max inclusive facet, set it to 100, and add it to the simple type's facet contents.
//
XSDMaxInclusiveFacet xsdMaxInclusiveFacet = xsdFactory.createXSDMaxInclusiveFacet();
xsdMaxInclusiveFacet.setLexicalValue("100");
simpleTypeDefinition.getFacetContents().add(xsdMaxInclusiveFacet);
// Add the simple type to the schema
//
prototypeSchema.getContents().add(simpleTypeDefinition);
// This is the result that is produced.
//
// <xsd:simpleType name="SimpleTypeDefinition">
// <xsd:annotation/>
// <xsd:restriction base="xsd:positiveInteger">
// <xsd:maxInclusive value="100"/>
// </xsd:restriction>
// </xsd:simpleType>
}
public void initializeSimpleListTypeDefinition()
{
// Create a simple list type definition and set it's name to SimpleListTypeDefinition.
// Also set its item type to the built-in integer.
//
XSDSimpleTypeDefinition simpleListTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
simpleListTypeDefinition.setName("SimpleListTypeDefinition");
simpleListTypeDefinition.setItemTypeDefinition
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("integer"));
// Create an annotation placeholder and add it to the type.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleListTypeDefinition.setAnnotation(annotation);
// Add the simple list type to the schema
//
prototypeSchema.getContents().add(simpleListTypeDefinition);
// This is the result that is produced.
//
// <xsd:simpleType name="SimpleListTypeDefinition">
// <xsd:annotation/>
// <xsd:list itemType="xsd:integer"/>
// </xsd:simpleType>
}
public void initializeSimpleUnionTypeDefinition()
{
// Create a simple list type definition and set it's name to SimpleUnionTypeDefinition.
// Also set its item type to the built-in integer.
//
XSDSimpleTypeDefinition simpleUnionTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
simpleUnionTypeDefinition.setName("SimpleUnionTypeDefinition");
simpleUnionTypeDefinition.getMemberTypeDefinitions().add
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("integer"));
// Create an annotation placeholder and add it to the type.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleUnionTypeDefinition.setAnnotation(annotation);
// Add the simple list type to the schema
//
prototypeSchema.getContents().add(simpleUnionTypeDefinition);
// This is the result that is produced.
//
// <xsd:simpleType name="SimpleUnionTypeDefinition">
// <xsd:annotation/>
// <xsd:union memberTypes="xsd:integer"/>
// </xsd:simpleType>
}
public void initializeFancyListTypeDefinition()
{
// Create a fancy list type definition and set it's name to FancyListTypeDefinition.
//
XSDSimpleTypeDefinition fancyListTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
fancyListTypeDefinition.setName("FancyListTypeDefinition");
// Create an anonymous list type definition for fancyListTypeDefinition to restrict.
//
XSDSimpleTypeDefinition listTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
// Create an anonymous union type definition for the item type of the listTypeDefiniton.
//
XSDSimpleTypeDefinition unionTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
// Create an anonymous "member" type definition for the unionTypeDefinition,
// and set it to restrict the built-in string.
//
XSDSimpleTypeDefinition firstMemberTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
firstMemberTypeDefinition.setBaseTypeDefinition
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
// Create an enumeration facet to specify the value "unknown" and add it to the member.
//
XSDEnumerationFacet xsdEnumerationFacet = xsdFactory.createXSDEnumerationFacet();
xsdEnumerationFacet.setLexicalValue("unknown");
firstMemberTypeDefinition.getFacetContents().add(xsdEnumerationFacet);
// Add the anonymous member to the contents and the member type definitions of unionTypeDefinition.
//
unionTypeDefinition.getContents().add(firstMemberTypeDefinition);
unionTypeDefinition.getMemberTypeDefinitions().add(firstMemberTypeDefinition);
// Create another anonymous "member" type definition for the unionTypeDefinition,
// and set it to restrict the built-in decimal.
//
XSDSimpleTypeDefinition secondMemberTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
secondMemberTypeDefinition.setBaseTypeDefinition
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("decimal"));
// Create a fraction digits facet to specify the value "2" and add it to the member.
//
XSDFractionDigitsFacet xsdFractionDigitsFacet = xsdFactory.createXSDFractionDigitsFacet();
xsdFractionDigitsFacet.setLexicalValue("2");
secondMemberTypeDefinition.getFacetContents().add(xsdFractionDigitsFacet);
// Add the anonymous member to the contents and the member type definitions of unionTypeDefinition.
//
unionTypeDefinition.getContents().add(secondMemberTypeDefinition);
unionTypeDefinition.getMemberTypeDefinitions().add(secondMemberTypeDefinition);
// Add the anonymous item to the contents and set the item type definition.
//
listTypeDefinition.getContents().add(unionTypeDefinition);
listTypeDefinition.setItemTypeDefinition(unionTypeDefinition);
// Add the anonymous restriction to the contents and set the base type definition.
//
fancyListTypeDefinition.getContents().add(listTypeDefinition);
fancyListTypeDefinition.setBaseTypeDefinition(listTypeDefinition);
// Create a max length facet to specify the value "4" and add it to the fancy list.
//
XSDMaxLengthFacet xsdMaxLengthFacet = xsdFactory.createXSDMaxLengthFacet();
xsdMaxLengthFacet.setLexicalValue("4");
fancyListTypeDefinition.getFacetContents().add(xsdMaxLengthFacet);
// Add the fancy list type to the schema.
//
prototypeSchema.getContents().add(fancyListTypeDefinition);
// This is the result that is produced.
//
// <xsd:simpleType name="FancyListTypeDefinition">
// <xsd:restriction>
// <xsd:simpleType>
// <xsd:list>
// <xsd:simpleType>
// <xsd:union>
// <xsd:simpleType>
// <xsd:restriction base="xsd:string">
// <xsd:enumeration value="unknown"/>
// </xsd:restriction>
// </xsd:simpleType>
// <xsd:simpleType>
// <xsd:restriction base="xsd:decimal">
// <xsd:fractionDigits value="2"/>
// </xsd:restriction>
// </xsd:simpleType>
// </xsd:union>
// </xsd:simpleType>
// </xsd:list>
// </xsd:simpleType>
// <xsd:maxLength value="4"/>
// </xsd:restriction>
// </xsd:simpleType>
}
public void initializeSimpleContentComplexTypeDefinition()
{
// Create a complex type definition and set its name to SimpleContentComplexTypeDefinition.
// Set it to be an extension
//
XSDComplexTypeDefinition simpleContentComplexTypeDefinition = xsdFactory.createXSDComplexTypeDefinition();
simpleContentComplexTypeDefinition.setName("SimpleContentComplexTypeDefinition");
simpleContentComplexTypeDefinition.setDerivationMethod(XSDDerivationMethod.EXTENSION_LITERAL);
// Create an annotation placeholder and add it to the complex type.
//
XSDAnnotation annotation = xsdFactory.createXSDAnnotation();
simpleContentComplexTypeDefinition.setAnnotation(annotation);
// Create an anonymous simple type definition, set its base type to be the built-in string,
// and set it to be the content type of the complex type.
//
XSDSimpleTypeDefinition anonymousSimpleTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
simpleContentComplexTypeDefinition.setBaseTypeDefinition
(prototypeSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
simpleContentComplexTypeDefinition.setContent(anonymousSimpleTypeDefinition);
// Create an attribute reference to simpleAttributeDeclaration in this schema.
//
XSDAttributeDeclaration simpleAttributeDeclarationReference = xsdFactory.createXSDAttributeDeclaration();
simpleAttributeDeclarationReference.setResolvedAttributeDeclaration
(prototypeSchema.resolveAttributeDeclaration("simpleAttributeDeclaration"));
// Create an attribute use to hold the reference, set its use to be optional,
// and add it to the complex type's attribute contents
//
XSDAttributeUse simpleAttributeUse = xsdFactory.createXSDAttributeUse();
simpleAttributeUse.setContent(simpleAttributeDeclarationReference);
simpleAttributeUse.setUse(XSDAttributeUseCategory.OPTIONAL_LITERAL);
simpleContentComplexTypeDefinition.getAttributeContents().add(simpleAttributeUse);
// Add the complex type to the schema.
//
prototypeSchema.getContents().add(simpleContentComplexTypeDefinition);
// This is the result that is produced.
//
// <xsd:complexType name="SimpleContentComplexTypeDefinition">
// <xsd:annotation/>
// <xsd:simpleContent>
// <xsd:extension base="xsd:string">
// <xsd:attribute ref="PTS:simpleAttributeDeclaration" use="optional"/>
// </xsd:extension>
// </xsd:simpleContent>
// </xsd:complexType>
}
public XSDSchema initializePurchaseOrderSchema()
{
// Build the Purchase Order Schema from Primer 0.
// The general approach, for efficiency, is to attach objects as late as possible.
// The XML serialization is at the end.
// Create the schema.
//
XSDSchema xsdSchema = XSDFactory.eINSTANCE.createXSDSchema();
// If you want schema tags and references to schema types to be qualified,
// which is recommend, this is the recommended qualifier.
//
xsdSchema.setSchemaForSchemaQNamePrefix("xsd");
// Set the target namespace.
//
xsdSchema.setTargetNamespace("http://nist.gov/po.xsd");
// Choose the prefix used for this schema's namespace and the schema for schema's namespace.
//
Map qNamePrefixToNamespaceMap = xsdSchema.getQNamePrefixToNamespaceMap();
qNamePrefixToNamespaceMap.put("po", xsdSchema.getTargetNamespace());
qNamePrefixToNamespaceMap.put(xsdSchema.getSchemaForSchemaQNamePrefix(), XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001);
// Create an annotation and add it to the schema.
//
XSDAnnotation xsdAnnotation = xsdFactory.createXSDAnnotation();
xsdSchema.getContents().add(xsdAnnotation);
// Create a documentation DOM element with no sourceURI attribute.
// NOTE
// Working with the contents of an annotation requires dropping down into the DOM model.
// This imposes the additional requirement that the annotation must be attached to a schema.
// It also has the effect of calling XSDConcreteComponent.updateElement(),
// if the schema does not have an element or document yet.
//
Element documentation = xsdAnnotation.createUserInformation(null);
// Use the DOM API to set the lang attribute and content of the documentation.
//
documentation.setAttributeNS(XSDConstants.XML_NAMESPACE_URI_1998, "xml:lang", "en");
String text = "Purchase order schema for Example.com.\nCopyright 2000 Example.com. All rights reserved.";
documentation.appendChild(documentation.getOwnerDocument().createTextNode(text));
// Use the DOM API to add the documentation to the element of the annotation.
//
xsdAnnotation.getElement().appendChild(documentation);
// Create an element, name it purchaseOrder,
// and set it's type to the purchaseOrderType of this schema.
// Add the purchaseOrder element to the schema.
//
XSDElementDeclaration purchaseOrder = xsdFactory.createXSDElementDeclaration();
purchaseOrder.setName("purchaseOrder");
purchaseOrder.setTypeDefinition(xsdSchema.resolveComplexTypeDefinition("PurchaseOrderType"));
xsdSchema.getContents().add(purchaseOrder);
// Create an element named command of the build-in type string.
//
XSDElementDeclaration comment = xsdFactory.createXSDElementDeclaration();
comment.setName("comment");
comment.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
xsdSchema.getContents().add(comment);
// Create a complex type and name it PurchaseOrderType.
//
XSDComplexTypeDefinition purchaseOrderType = xsdFactory.createXSDComplexTypeDefinition();
purchaseOrderType.setName("PurchaseOrderType");
// Create a sequence model group, and a particle to contain it.
//
XSDModelGroup purchaseOrderTypeSequence = xsdFactory.createXSDModelGroup();
purchaseOrderTypeSequence.setCompositor(XSDCompositor.SEQUENCE_LITERAL);
XSDParticle purchaseOrderTypeParticle = xsdFactory.createXSDParticle();
purchaseOrderTypeParticle.setContent(purchaseOrderTypeSequence);
// Create an element named shipTo of complex type USAddress, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration shipTo = xsdFactory.createXSDElementDeclaration();
shipTo.setName("shipTo");
shipTo.setTypeDefinition(xsdSchema.resolveComplexTypeDefinition("USAddress"));
XSDParticle shipToParticle = xsdFactory.createXSDParticle();
shipToParticle.setContent(shipTo);
purchaseOrderTypeSequence.getContents().add(shipToParticle);
// Create an element named billTo of complex type USAddress, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration billTo = xsdFactory.createXSDElementDeclaration();
billTo.setName("billTo");
billTo.setTypeDefinition(xsdSchema.resolveComplexTypeDefinition("USAddress"));
XSDParticle billToParticle = xsdFactory.createXSDParticle();
billToParticle.setContent(billTo);
purchaseOrderTypeSequence.getContents().add(billToParticle);
// Create an element reference to comment, a particle to contain it,
// set the particle to be optional, and add the particle to the sequence.
//
XSDElementDeclaration commentRef = xsdFactory.createXSDElementDeclaration();
commentRef.setResolvedElementDeclaration(xsdSchema.resolveElementDeclaration("comment"));
XSDParticle commentRefParticle = xsdFactory.createXSDParticle();
commentRefParticle.setMinOccurs(0);
commentRefParticle.setContent(commentRef);
purchaseOrderTypeSequence.getContents().add(commentRefParticle);
// Create an element named items of complex type Items, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration items = xsdFactory.createXSDElementDeclaration();
items.setName("items");
items.setTypeDefinition(xsdSchema.resolveComplexTypeDefinition("Items"));
XSDParticle itemsParticle = xsdFactory.createXSDParticle();
itemsParticle.setContent(items);
purchaseOrderTypeSequence.getContents().add(billToParticle);
// Set the completed content particle to be the content of the PurchaseOrderType.
//
purchaseOrderType.setContent(purchaseOrderTypeParticle);
// Create an attribute, name it orderDate, and set it's type to the built-in Date type.
// Also create an attribute use to contain the attribute and add it to PurchaseOrderType's attribute contents.
//
XSDAttributeDeclaration orderDate = xsdFactory.createXSDAttributeDeclaration();
orderDate.setName("orderDate");
orderDate.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("date"));
XSDAttributeUse orderDateAttributeUse = xsdFactory.createXSDAttributeUse();
orderDateAttributeUse.setContent(orderDate);
purchaseOrderType.getAttributeContents().add(orderDateAttributeUse);
// Add the completed complex PurchaseOrderType to the schema.
//
xsdSchema.getContents().add(purchaseOrderType);
// Create a complex type named USAddress.
//
XSDComplexTypeDefinition usAddress = xsdFactory.createXSDComplexTypeDefinition();
usAddress.setName("USAddress");
// Create a sequence model group, and a particle to contain it.
//
XSDModelGroup usAddressSequence = xsdFactory.createXSDModelGroup();
usAddressSequence.setCompositor(XSDCompositor.SEQUENCE_LITERAL);
XSDParticle usAddressParticle = xsdFactory.createXSDParticle();
usAddressParticle.setContent(usAddressSequence);
// Create an element named name of built-in type string, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration name = xsdFactory.createXSDElementDeclaration();
name.setName("name");
name.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
XSDParticle nameParticle = xsdFactory.createXSDParticle();
nameParticle.setContent(name);
usAddressSequence.getContents().add(nameParticle);
// Create an element named street of built-in type string, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration street = xsdFactory.createXSDElementDeclaration();
street.setName("street");
street.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
XSDParticle streeParticle = xsdFactory.createXSDParticle();
streeParticle.setContent(street);
usAddressSequence.getContents().add(streeParticle);
// Create an element named city of built-in type string, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration city = xsdFactory.createXSDElementDeclaration();
city.setName("city");
city.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
XSDParticle cityParticle = xsdFactory.createXSDParticle();
cityParticle.setContent(city);
usAddressSequence.getContents().add(cityParticle);
// Create an element named state of built-in type string, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration state = xsdFactory.createXSDElementDeclaration();
state.setName("state");
state.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
XSDParticle stateParticle = xsdFactory.createXSDParticle();
stateParticle.setContent(state);
usAddressSequence.getContents().add(stateParticle);
// Create an element named zip of built-in type string, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration zip = xsdFactory.createXSDElementDeclaration();
zip.setName("zip");
zip.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
XSDParticle zipParticle = xsdFactory.createXSDParticle();
zipParticle.setContent(zip);
usAddressSequence.getContents().add(zipParticle);
// Set the completed content particle to be the content of USAddress.
//
usAddress.setContent(usAddressParticle);
// Create an attribute, name it country, set it's type to the built-in NMTOKEN type,
// set its constraints to be fixed, set the lexical value of the constraint to be "US".
// Also create an attribute use to contain the attribute and add it to USAddress' attribute contents.
//
XSDAttributeDeclaration country = xsdFactory.createXSDAttributeDeclaration();
country.setName("country");
country.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("NMTOKEN"));
XSDAttributeUse countryAttributeUse = xsdFactory.createXSDAttributeUse();
countryAttributeUse.setContent(country);
countryAttributeUse.setConstraint(XSDConstraint.FIXED_LITERAL);
countryAttributeUse.setLexicalValue("US");
usAddress.getAttributeContents().add(countryAttributeUse);
// Add the completed complex USAddress to the schema.
//
xsdSchema.getContents().add(usAddress);
// Create a complex type named Items.
//
XSDComplexTypeDefinition itemsType = xsdFactory.createXSDComplexTypeDefinition();
itemsType.setName("Items");
// Create a sequence model group, and a particle to contain it.
//
XSDModelGroup itemsTypeSequence = xsdFactory.createXSDModelGroup();
itemsTypeSequence.setCompositor(XSDCompositor.SEQUENCE_LITERAL);
XSDParticle itemsTypeParticle = xsdFactory.createXSDParticle();
itemsTypeParticle.setContent(itemsTypeSequence);
// Create an element and name it item.
//
XSDElementDeclaration item = xsdFactory.createXSDElementDeclaration();
item.setName("item");
// Create an anonymous complex type.
//
XSDComplexTypeDefinition anonymousComplexTypeDefinition = xsdFactory.createXSDComplexTypeDefinition();
// Create a sequence model group, and a particle to contain it.
//
XSDModelGroup anonymousComplexTypeDefinitionSequence = xsdFactory.createXSDModelGroup();
anonymousComplexTypeDefinitionSequence.setCompositor(XSDCompositor.SEQUENCE_LITERAL);
XSDParticle anonymousTypeDefinitionParticle = xsdFactory.createXSDParticle();
anonymousTypeDefinitionParticle.setContent(anonymousComplexTypeDefinitionSequence);
// Create an element productName of built-in type string, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration productName = xsdFactory.createXSDElementDeclaration();
productName.setName("productName");
productName.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
XSDParticle productNameParticle = xsdFactory.createXSDParticle();
productNameParticle.setContent(productName);
anonymousComplexTypeDefinitionSequence.getContents().add(productNameParticle);
// Create a particle to contain the item declaration and add it to the sequence.
//
XSDParticle itemParticle = xsdFactory.createXSDParticle();
itemParticle.setContent(item);
itemsTypeSequence.getContents().add(itemParticle);
// Create an attribute, name it partNum, set its type to the SKU type,
// Also create an attribute use to contain the attribute, set it to be required,
// and add it to Items' attribute contents.
//
XSDAttributeDeclaration partNum = xsdFactory.createXSDAttributeDeclaration();
partNum.setName("partNum");
partNum.setTypeDefinition(xsdSchema.resolveSimpleTypeDefinition("SKU"));
XSDAttributeUse partNumAttributeUse = xsdFactory.createXSDAttributeUse();
partNumAttributeUse.setContent(partNum);
partNumAttributeUse.setUse(XSDAttributeUseCategory.REQUIRED_LITERAL);
itemsType.getAttributeContents().add(partNumAttributeUse);
// Set the completed content particle to be the content of the anonymous complex type.
//
anonymousComplexTypeDefinition.setContent(anonymousTypeDefinitionParticle);
// Create an element and name it quantity.
//
XSDElementDeclaration quantity = xsdFactory.createXSDElementDeclaration();
quantity.setName("quantity");
// Create an anonymous simple type and set it to restrict the built-in positiveInteger type.
//
XSDSimpleTypeDefinition anonymousSimpleTypeDefinition = xsdFactory.createXSDSimpleTypeDefinition();
anonymousSimpleTypeDefinition.setBaseTypeDefinition
(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("positiveInteger"));
// Create max exclusive facet, set its lexical value to be 100, and add it to the facet contents of the anonymous simple type.
//
XSDMaxExclusiveFacet quantityMaxExclusiveFacet = xsdFactory.createXSDMaxExclusiveFacet();
quantityMaxExclusiveFacet.setLexicalValue("100");
anonymousSimpleTypeDefinition.getFacetContents().add(quantityMaxExclusiveFacet);
// Set the completed anonymous type of the quantity element.
//
quantity.setAnonymousTypeDefinition(anonymousSimpleTypeDefinition);
// Create a particle to hold the quantity element and add it to the sequence.
//
XSDParticle quantityParticle = xsdFactory.createXSDParticle();
quantityParticle.setContent(quantity);
anonymousComplexTypeDefinitionSequence.getContents().add(quantityParticle);
// Create an element USPrice of built-in type decimal, a particle to contain it,
// and add the particle to the sequence.
//
XSDElementDeclaration usPrice = xsdFactory.createXSDElementDeclaration();
usPrice.setName("USPrice");
usPrice.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("decimal"));
XSDParticle usPriceParticle = xsdFactory.createXSDParticle();
usPriceParticle.setContent(usPrice);
anonymousComplexTypeDefinitionSequence.getContents().add(usPriceParticle);
// Create an element reference to comment, a particle to contain it,
// set the particle to be optional, and add the particle to the sequence.
//
XSDElementDeclaration anotherCommentRef = xsdFactory.createXSDElementDeclaration();
anotherCommentRef.setResolvedElementDeclaration(xsdSchema.resolveElementDeclaration("comment"));
XSDParticle anotherCommentRefParticle = xsdFactory.createXSDParticle();
anotherCommentRefParticle.setMinOccurs(0);
anotherCommentRefParticle.setContent(anotherCommentRef);
anonymousComplexTypeDefinitionSequence.getContents().add(anotherCommentRefParticle);
// Create an element USPrice of built-in type Date, a particle to contain it,
// set the particle to be optional, and add it to the sequence.
//
XSDElementDeclaration shipDate = xsdFactory.createXSDElementDeclaration();
shipDate.setName("shipDate");
shipDate.setTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("decimal"));
XSDParticle shipDateParticle = xsdFactory.createXSDParticle();
shipDateParticle.setContent(shipDate);
shipDateParticle.setMinOccurs(0);
anonymousComplexTypeDefinitionSequence.getContents().add(shipDateParticle);
// Set the completed content particle to be the content of Items.
//
itemsType.setContent(itemsTypeParticle);
// Set the completed anonymous type of the item element.
//
item.setAnonymousTypeDefinition(anonymousComplexTypeDefinition);
// Add the completed complex Items to the schema.
//
xsdSchema.getContents().add(itemsType);
// Create a simple type, name it Sku, and set it to restrict the built-in type string.
//
XSDSimpleTypeDefinition sku = xsdFactory.createXSDSimpleTypeDefinition();
sku.setName("Sku");
sku.setBaseTypeDefinition(xsdSchema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
// Create max exclusive facet, set its lexical value to be 100, and add it to the facet contents of Sku.
//
XSDPatternFacet skuPatternFacet = xsdFactory.createXSDPatternFacet();
skuPatternFacet.setLexicalValue("/d{3}-[A-Z]{2}");
sku.getFacetContents().add(skuPatternFacet);
// Add the completed simple Sku to the schema.
//
xsdSchema.getContents().add(sku);
// This is the result that is produced.
//
// <?xml version="1.0" encoding="UTF-8"?>
// <xsd:schema targetNamespace="http://nist.gov/po.xsd"
// xmlns:po="http://nist.gov/po.xsd" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
// <xsd:annotation>
// <xsd:documentation xml:lang="en">Purchase order schema for
// Example.com. Copyright 2000 Example.com. All rights reserved.</xsd:documentation>
// </xsd:annotation>
// <xsd:element name="purchaseOrder" type="po:PurchaseOrderType"/>
// <xsd:element name="comment" type="xsd:string"/>
// <xsd:complexType name="PurchaseOrderType">
// <xsd:sequence>
// <xsd:element name="shipTo" type="po:USAddress"/>
// <xsd:element name="billTo" type="po:USAddress"/>
// <xsd:element minOccurs="0" ref="po:comment"/>
// </xsd:sequence>
// <xsd:attribute name="orderDate" type="xsd:Date"/>
// </xsd:complexType>
// <xsd:complexType name="USAddress">
// <xsd:sequence>
// <xsd:element name="name" type="xsd:string"/>
// <xsd:element name="street" type="xsd:string"/>
// <xsd:element name="city" type="xsd:string"/>
// <xsd:element name="state" type="xsd:string"/>
// <xsd:element name="zip" type="xsd:string"/>
// </xsd:sequence>
// <xsd:attribute fixed="US" name="country" type="xsd:NMTOKEN"/>
// </xsd:complexType>
// <xsd:complexType name="Items">
// <xsd:sequence>
// <xsd:element name="item">
// <xsd:complexType>
// <xsd:sequence>
// <xsd:element name="productName" type="xsd:string"/>
// <xsd:element name="quantity">
// <xsd:simpleType>
// <xsd:restriction base="xsd:positiveInteger">
// <xsd:maxExclusive value="100"/>
// </xsd:restriction>
// </xsd:simpleType>
// </xsd:element>
// <xsd:element name="USPrice" type="xsd:decimal"/>
// <xsd:element minOccurs="0" ref="po:comment"/>
// <xsd:element minOccurs="0" name="shipDate" type="xsd:decimal"/>
// </xsd:sequence>
// </xsd:complexType>
// </xsd:element>
// </xsd:sequence>
// <xsd:attribute name="partNum" type="po:SKU" use="required"/>
// </xsd:complexType>
// <xsd:simpleType name="Sku">
// <xsd:restriction base="xsd:string">
// <xsd:pattern value="/d{3}-[A-Z]{2}"/>
// </xsd:restriction>
// </xsd:simpleType>
// </xsd:schema>
return xsdSchema;
}
public void savePurchaseOrderSchema(java.lang.String schemaURI)
{
// Saves the Purchase Order Schema to the given URI.
//
try
{
// Create a resource set and a resource with an extent.
// Add the schema to the extent, add the resource to the set,
// and save the resource.
//
ResourceSet resourceSet = new ResourceSetImpl();
Resource resource = new XSDResourceImpl(URI.createURI(schemaURI));
resource.getContents().add(purchaseOrderSchema);
resourceSet.getResources().add(resource);
resource.save(Collections.EMPTY_MAP);
}
catch (Exception exception)
{
System.out.println(exception.getLocalizedMessage());
exception.printStackTrace();
}
}
public void printSchema(java.lang.String xsdSchemaURI)
{
// Prints the schema loaded from the given URI.
//
// The code assumes that the following registration has taken place.
// Currently, unless special handling is implemented in the resource set,
// only files ending with a .xsd extension will be loaded as schemas.
//
// Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("xsd", new XSDResourceFactoryImpl());
try
{
// Create a resource set,
// turn on the ability of the XSDParser to associate line and column information with the DOM,
// and then load the main schema file.
//
ResourceSet resourceSet = new ResourceSetImpl();
resourceSet.getLoadOptions().put(XSDResourceImpl.XSD_TRACK_LOCATION, Boolean.TRUE);
XSDResourceImpl xsdSchemaResource = (XSDResourceImpl)resourceSet.getResource(URI.createURI(xsdSchemaURI), true);
// Iterate over all the resources, i.e., the main resource
// and those that have been included, imported, or redefined.
//
for (Iterator resources = resourceSet.getResources().iterator(); resources.hasNext(); )
{
// Check for schema resources.
//
Resource resource = (Resource)resources.next();
if (resource instanceof XSDResourceImpl)
{
XSDResourceImpl xsdResource = (XSDResourceImpl)resource;
// Get the schema's element and serialized it to System.out.
//
XSDSchema xsdSchema = xsdResource.getSchema();
System.out.println("\n<!-- *** " + xsdResource.getURI() + " *** -->\n");
printComponent(System.out, xsdSchema);
// If there are no errors from just trying to parse a DOM,
// validate the schema.
//
if (xsdSchema.getAllDiagnostics().isEmpty())
{
xsdSchema.validate();
}
// Process each of the diagnostics.
//
for (Iterator diagnostics = xsdSchema.getAllDiagnostics().iterator(); diagnostics.hasNext(); )
{
XSDDiagnostic xsdDiagnostic = (XSDDiagnostic)diagnostics.next();
String localizedSeverity =
XSDPlugin.INSTANCE.getString("_UI_XSDDiagnosticSeverity_" + xsdDiagnostic.getSeverity());
System.out.println
(XSDPlugin.INSTANCE.getString
("_UI_DiagnosticFileLineColumn_message",
new Object []
{
localizedSeverity,
xsdDiagnostic.getLocationURI(),
new Integer(xsdDiagnostic.getLine()),
new Integer(xsdDiagnostic.getColumn())
}));
System.out.println(xsdDiagnostic.getMessage());
}
}
}
}
catch (Exception exception)
{
System.out.println(exception.getLocalizedMessage());
exception.printStackTrace();
}
}
public void printComponent(java.io.OutputStream outputStream,
XSDConcreteComponent xsdConcreteComponent)
{
// Print a component's element using Xerces.
//
// Get the component's element and create one if there isn't one already.
//
Element element = xsdConcreteComponent.getElement();
if (element == null)
{
xsdConcreteComponent.updateElement();
element = xsdConcreteComponent.getElement();
}
if (element != null)
{
try
{
// OutputFormat outputFormat = new OutputFormat(element.getOwnerDocument());
// outputFormat.setLineWidth(80);
// outputFormat.setIndenting(true);
// outputFormat.setIndent(4);
// outputFormat.setPreserveSpace(false);
// XMLSerializer serializer = new XMLSerializer(outputStream, outputFormat);
// serializer.serialize(element);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.transform(new DOMSource(element.getOwnerDocument()), new StreamResult(outputStream));
}
catch (TransformerException exception)
{
System.out.println(exception.getLocalizedMessage());
exception.printStackTrace();
}
}
}
public XSDSchema createSchema(org.w3c.dom.Element element)
{
// Create a schema from an element.
//
// Test if the element is really a schema element.
//
if (element.getLocalName().equals("schema") &&
XSDConstants.isSchemaForSchemaNamespace(element.getNamespaceURI()))
{
// Create the schema.
//
XSDSchema xsdSchema = XSDFactory.eINSTANCE.createXSDSchema();
// Set the element to the schema.
// This it will build the corresponding component structure.
//
xsdSchema.setElement(element);
return xsdSchema;
}
else
{
return null;
}
}
public void traceLoading(java.lang.String xsdSchemaURI)
{
// Traces a resource set's loading behavior when loading the given URI.
//
// The code assumes that the following registration has taken place.
// Currently, unless special handling is implemented in the resource set,
// only files ending with a .xsd extension will be loaded as schemas.
//
// Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("xsd", new XSDResourceFactoryImpl());
try
{
// Create a resource set.
//
ResourceSet resourceSet =
new ResourceSetImpl()
{
public Resource getResource(URI uri, boolean loadOnDemand)
{
Resource result = super.getResource(uri, true);
System.out.println("<!-- loaded: " + uri + " --> " + result);
return result;
}
};
// Create a derived URIConverter to track normalization.
//
resourceSet.getURIConverter().getURIMap().put
(URI.createURI("http://www.example.com/logical.xsd"),
URI.createURI("file://c:/physical.xsd"));
// Load the schema from the URI.
//
XSDResourceImpl xsdSchemaResource = (XSDResourceImpl)resourceSet.getResource(URI.createURI(xsdSchemaURI), true);
// Iterate over all the resources, i.e., the main resource
// and those that have been included, imported, or redefined.
//
for (Iterator resources = resourceSet.getResources().iterator(); resources.hasNext(); )
{
// Check for schema resources.
//
Resource resource = (Resource)resources.next();
if (resource instanceof XSDResourceImpl)
{
XSDResourceImpl xsdResource = (XSDResourceImpl)resource;
// Iterate over the schema's content's looking for directives.
//
XSDSchema xsdSchema = xsdResource.getSchema();
for (Iterator contents = xsdSchema.getContents().iterator(); contents.hasNext(); )
{
XSDSchemaContent xsdSchemaContent = (XSDSchemaContent)contents.next();
if (xsdSchemaContent instanceof XSDSchemaDirective)
{
// Check if the directive resolved to a schema.
//
XSDSchemaDirective xsdSchemaDirective = (XSDSchemaDirective)xsdSchemaContent;
if (xsdSchemaDirective.getResolvedSchema() == null)
{
System.out.println("Unresolved schema in " + xsdResource.getURI());
printComponent(System.out, xsdSchemaDirective);
}
}
}
}
}
}
catch (Exception exception)
{
System.out.println(exception.getLocalizedMessage());
exception.printStackTrace();
}
}
public XSDConcreteComponent cloneComponent(XSDConcreteComponent xsdConcreteComponent,
boolean preserveDOM)
{
// A component can be cloned directly or by cloning the underlying DOM.
// By cloning the DOM you ensure that <annotation>s, non-schema namespace attributes, and formatting are preserved.
//
if (preserveDOM)
{
// If there is an element to clone.
//
Element element = xsdConcreteComponent.XSDConcreteComponent.getElement()getElement();
if (element != null)
{
// Clone the DOM using the DOM API, and create the same type of component to hold it.
//
Element clonedElement = (Element)element.cloneNode(true);
XSDConcreteComponent result = (XSDConcreteComponent)XSDFactory.eINSTANCE.create(xsdConcreteComponent.eClass());
result.setElement(clonedElement);
return result;
}
}
// Clone just the model itself so that a new DOM will need to be created to serialize it.
//
XSDConcreteComponent result = xsdConcreteComponent.cloneConcreteComponent(true, false);
return result;
}
public void crossReferenceTest(java.io.PrintStream out)
{
// Test cross references for the meta schemas.
//
XSDSchema xsdSchemaForSchema = XSDUtil.getSchemaForSchema(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001);
ResourceSet resourceSet = xsdSchemaForSchema.eResource().getResourceSet();
out.println("Show uses of the string datatype within the meta schemas themselves.");
Collection usages = XSDUtil.UsageCrossReferencer.find(xsdSchemaForSchema.resolveSimpleTypeDefinition("string"), resourceSet);
XSDUtil.UsageCrossReferencer.print(out, usages);
out.println("Show uses of the ur-type URI");
Map xsdURICrossReferences = XSDUtil.URICrossReferencer.find(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001 + "#anyType", resourceSet);
XSDUtil.URICrossReferencer.print(out, xsdURICrossReferences);
out.println("Show all named components and their uses in the schema of the anySimpleType.");
Map xsdNamedComponentUsage =
XSDUtil.XSDNamedComponentCrossReferencer.find(xsdSchemaForSchema.resolveSimpleTypeDefinition("anySimpleType").getSchema());
XSDUtil.XSDNamedComponentCrossReferencer.print(out, xsdNamedComponentUsage);
out.println("Test that the URI of evey object in the schema for schemas can be resolved.");
for (Iterator contents = xsdSchemaForSchema.eAllContents(); contents.hasNext(); )
{
XSDConcreteComponent xsdConcreteComponent = (XSDConcreteComponent)contents.next();
URI uri = EcoreUtil.getURI(xsdConcreteComponent);
if (resourceSet.getEObject(uri, false) != xsdConcreteComponent)
{
out.println("BAD URI: " + uri);
}
}
}
|
Copyright 2001-2006 IBM Corporation and others. All Rights Reserved. |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||