| <!doctype HTML public "-//W3C//DTD HTML 4.0 Frameset//EN"> |
| |
| <!-- Copyright 2004 The Apache Software Foundation |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. --> |
| <html> |
| <head> |
| <!-- InstanceBeginEditable name="doctitle" --> |
| <title>Introduction to Schema Type Signatures</title> |
| <!-- InstanceEndEditable --> |
| <!--(Meta)==========================================================--> |
| |
| <meta http-equiv=Content-Type content="text/html; charset=$CHARSET;"> |
| |
| |
| <!-- InstanceBeginEditable name="metatags" --> |
| |
| <meta content="your name" name="author"> |
| <meta content="A description of the topic contents." name="description"> |
| <meta content="keywords to help in searches" name="keywords"> |
| <meta content="10/25/02" name="date last modified"> |
| <!-- InstanceEndEditable --> |
| |
| <!--(Links)=========================================================--> |
| <!-- InstanceBeginEditable name="head" --> |
| <link href="../xmlbeans.css" rel="stylesheet" type="text/css"> |
| <!-- InstanceEndEditable --> |
| <link href="../xmlbeans.css" rel="stylesheet" type="text/css"> |
| <a href="../../../core/index.html" id="index"></a> |
| <script language="JavaScript" src="../../../core/topicInfo.js"></script> |
| <script language="JavaScript" src="../../../core/CookieClass.js"></script> |
| <script language="JavaScript" src="../../../core/displayContent.js"></script> |
| </head> |
| |
| <!--(Body)==========================================================--> |
| <body> |
| <script language="JavaScript"> |
| |
| </script> |
| <!-- InstanceBeginEditable name="body" --> |
| <h1> Introduction to Schema Type Signatures</h1> |
| <div id="topictext"> |
| <p>When you compile schema, the API generated from your schema is integrated |
| with the XMLBeans type system that represents the underlying XML schema. All |
| together, these types make up the <em>schema type system</em> to which your |
| code has access. When handling XML based on the schema, you typically call |
| methods of the API generated when you compiled the schema. However, for the |
| cases when you want to get information about the schema itself, you use the |
| schema type system API.</p> |
| <p>In the XMLBeans API, you have access to the system itself through <a href="../reference/org/apache/xmlbeans/SchemaTypeSystem.html"><span class="langinline">SchemaTypeSystem</span></a> |
| and related classes. These make up a kind of "meta-API," or a view |
| on the schema. You can use the schema type system API to discover the type |
| system at run time. See the reference topic on that interface for an overview |
| of the schema type system.</p> |
| <h2>Schema Type "Signatures"</h2> |
| <p>A schema is made up of schema components. Schema components are the pieces |
| of a schema, such as a type definition, an element declaration, attribute |
| declaration, and so on. To mirror these in the schema type system, a <a href="../reference/org/apache/xmlbeans/SchemaComponent.html"><span class="langinline">SchemaComponent</span></a> |
| instance represents a component in the underlying schema; separate components |
| have corresponding types. For example you would have a <span class="langinline"><a href="../reference/org/apache/xmlbeans/SchemaType.html">SchemaType</a></span> |
| object for a <span class="langinline">CustomerType</span> your schema defined, |
| or a <a href="../reference/org/apache/xmlbeans/SchemaGlobalElement.html"><span class="langinline">SchemaGlobalElement</span></a> |
| object for a global <span class="langinline">PurchaseOrder</span> element. |
| You would also have a <span class="langinline">SchemaType</span> for built-in |
| schema types, such as <span class="langinline">xs:string</span> or <span class="langinline">xs:datetime</span>. |
| XMLBean provides a "signature" to describe each type. You can retrieve |
| this signature by calling the SchemaType class's <span class="langinline">toString</span> |
| method.</p> |
| <p>The <span class="langinline">toString</span> method returns XMLBeans' version |
| of a unique signature for a schema type. This string is useful for debugging |
| because it describes a given type even when the type doesn't have a name. |
| </p> |
| <p class="notepara"><strong>Note:</strong> It's important to remember that this |
| signature is an XMLBeans convention, rather than a standard from the schema |
| working group. The working group has not yet standardized a signature for |
| XML schema types. As a result the signature you'll see from XMLBeans is subject |
| to change — whatever the schema working group comes up with in the end |
| (if anything) is probably what will be used by this API. In other words, don't |
| write a program to decode the signature.</p> |
| <p>You can use the following description to understand how a signature is constructed.</p> |
| </div> |
| <ul> |
| <li> |
| <div><strong>Global types.</strong> If the type has a name, it's a global |
| type. The following form is used:</div> |
| <div> |
| <div> |
| <pre>T=<localname>@<targetNamespace></pre> |
| </div> |
| </div> |
| <p>The "T" is for "type," of course. "localname" |
| is a convention used by qnames (qualified names), which include a local |
| name and the namespace URI (if any). So an example might be:</p> |
| <pre>T=customer@openuri.org</pre> |
| </li> |
| <li><strong>Document types and global attribute types.</strong> These correspond |
| to a special anonymous type containing one global element or attribute. These |
| special types are generated by XMLBeans to represent global types declared |
| with the <element> or <attribute> tag in schema. Because such |
| types are types, but are declared as elements or attributes, they require |
| special treatment. The following signature form is used: |
| <div> |
| <pre> |
| D=<document-element-name>@<targetNamespace> |
| R=<attribute-type-name>@<targetNamespace> |
| </pre> |
| <div></div> |
| </div> |
| <div> |
| <div>Note that these are also the signatures of a type returned by a FooDocument.type |
| or FooAttribute.type method call.</div> |
| </div> |
| </li> |
| <li><strong>Anonymous types.</strong> If the type is anonymous, it is defined |
| as an element or attribute, or within a further anonymous type. In this case, |
| the signature is built by establishing the local context (in order words, |
| what is the anonymous type nested in?). From the local context, the larger |
| context is built recursively. In other words, the signature is built by giving |
| not only the anonymous type itself, but also by describing its context. |
| <p> The following rules are used for building a signature for an anonymous |
| type. </p> |
| <ul> |
| <li> It might be an anonymous type defined inside a local element or attribute, |
| which in turn is defined within something else: |
| <p>If the element is <span class="langinline" style="langinline">form="qualified"</span> |
| (the usual default):</p> |
| </li> |
| </ul> |
| </li> |
| <blockquote> |
| <div> |
| <pre>E=<eltname>|<signature of the type within which the elt is defined></pre> |
| </div> |
| <div>If the element is <span class="langinline" style="langinline">form="unqualified"</span>:</div> |
| <div> |
| <pre>U=<eltname>|<signature of the type within which the elt is defined></pre> |
| </div> |
| <div>If the attribute is <span class="langinline" style="langline">form="unqualified"</span> |
| (the usual default):</div> |
| <div> |
| <pre>A=<attrname>|<signature of the type within the attr is defined></pre> |
| </div> |
| <div>if the attribute is <span class="langinline" style="langinline">form="qualified"</span>:</div> |
| <div> |
| <pre>Q=<attrname>|<signature of the type within the attr is defined></pre> |
| </div> |
| </blockquote> |
| <ul> |
| <li>It might be an anonymous type defined a simple restriction, union, or |
| list definition:</li> |
| </ul> |
| <blockquote> |
| <div> |
| <pre>M=#|<signature of the containing union type></pre> |
| <p>(The # is a number indicating which union member it is, by source order |
| — such as 0,1,2, etc.)</p> |
| <pre>B=|<signature of the containing base type for a restriction></pre> |
| <pre>I=|<signature of the containing list type></pre> |
| </div> |
| </blockquote> |
| <ul> |
| <li> |
| <div> In the future if anonymous types are allowed in some other context, |
| there may be more codes.</div> |
| </li> |
| </ul> |
| </ul> |
| <h2>An Example</h2> |
| <p>So, for example, if you have a type that describes the list items within an |
| attribute of an instance that looks like this:</p> |
| <blockquote> |
| <div> |
| <pre> <root mylist="432 999 143 123"/></pre> |
| </div> |
| </blockquote> |
| <div> The schema, if done with lots of nested types, could look something like |
| this:</div> |
| <blockquote> |
| <div> |
| <pre> |
| <schema targetNamespace="myNamespace" elementFormDefault="qualified"> |
| <element name="root"> |
| <complexType> |
| <attribute name="mylist"> |
| <simpleType> |
| <list> |
| <simpleType> <!--This is the type that the signature is for --> |
| <restriction base="xs:nonNegativeInteger"> |
| <totalDigits value="3"/>.. |
| </pre> |
| </div> |
| </blockquote> |
| <div> The signature for the simpleType indicated in the example would be:</div> |
| <blockquote> |
| <pre>I=|A=mylist|E=root|D=root@myNamespace</pre> |
| </blockquote> |
| <div> |
| <p>You could read this as: </p> |
| </div> |
| <blockquote> |
| <div>"The type of the list item | within the type of the mylist attribute's |
| type | within the type of the root element | within the document type for |
| <root> documents | in the myNamespace namespace".</div> |
| </blockquote> |
| <div> |
| <p>Note that the signature structure mirrors the Java class structure generated |
| by XMLBeans when compiling the schema. In other words, if you were to compile |
| a schema that included the preceding snippet, you would be able to access |
| an instance of the schema with Java code like the following:</p> |
| <pre>SchemaType sType = RootDocument.Root.MyList.Item.type;</pre> |
| </div> |
| <p class="relatedtopics">Related Topics</p> |
| <p><a href="conGettingStartedwithXMLBeans.html">Getting Started with XMLBeans</a></p> |
| <!-- InstanceEndEditable --> |
| <script language="JavaScript"> |
| |
| </script> |
| </body> |
| </html> |
