xmlbeans-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kkro...@apache.org
Subject svn commit: r151276 [1/3] - in xmlbeans/trunk: ./ docs/ docs/guide/ src/tools/org/apache/xmlbeans/impl/inst2xsd/ src/toolschema/ src/xmlpublic/org/apache/xmlbeans/ src/xpath_xquery/org/apache/xmlbeans/impl/xpath/saxon/
Date Fri, 04 Feb 2005 00:39:43 GMT
Author: kkrouse
Date: Thu Feb  3 16:39:39 2005
New Revision: 151276

URL: http://svn.apache.org/viewcvs?view=rev&rev=151276
Log:
adding apache license to more files

Modified:
    xmlbeans/trunk/build.xml
    xmlbeans/trunk/docs/guide/antXmlbean.html
    xmlbeans/trunk/docs/guide/conGettingStartedwithXMLBeans.html
    xmlbeans/trunk/docs/guide/conIntroToTheSchemaTypeSystem.html
    xmlbeans/trunk/docs/guide/conJavaTypesGeneratedFromUserDerived.html
    xmlbeans/trunk/docs/guide/conMethodsForGeneratedJavaTypes.html
    xmlbeans/trunk/docs/guide/conNavigatingXMLwithCursors.html
    xmlbeans/trunk/docs/guide/conSelectingXMLwithXQueryPathXPath.html
    xmlbeans/trunk/docs/guide/conUnderstandingXMLTokens.html
    xmlbeans/trunk/docs/guide/conUsingBookmarksToAnnotateXML.html
    xmlbeans/trunk/docs/guide/conXMLBeansSupportBuiltInSchemaTypes.html
    xmlbeans/trunk/docs/stylesheet.css
    xmlbeans/trunk/docs/xmlbeans.css
    xmlbeans/trunk/src/tools/org/apache/xmlbeans/impl/inst2xsd/XsdGenStrategy.java
    xmlbeans/trunk/src/toolschema/ltgfmt.xsd
    xmlbeans/trunk/src/toolschema/substwsdl.xsd
    xmlbeans/trunk/src/toolschema/xsdownload.xsd
    xmlbeans/trunk/src/xmlpublic/org/apache/xmlbeans/DelegateXmlObject.java
    xmlbeans/trunk/src/xmlpublic/org/apache/xmlbeans/message.properties
    xmlbeans/trunk/src/xmlpublic/org/apache/xmlbeans/package.html
    xmlbeans/trunk/src/xpath_xquery/org/apache/xmlbeans/impl/xpath/saxon/XBeansStandaloneContext.java
    xmlbeans/trunk/testbuild.xml

Modified: xmlbeans/trunk/build.xml
URL: http://svn.apache.org/viewcvs/xmlbeans/trunk/build.xml?view=diff&r1=151275&r2=151276
==============================================================================
--- xmlbeans/trunk/build.xml (original)
+++ xmlbeans/trunk/build.xml Thu Feb  3 16:39:39 2005
@@ -1,3 +1,18 @@
+<!--
+    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.
+-->
 <project name="Xbean" default="default" basedir=".">
 
     <property name="build.compiler" value="javac1.4"/>

Modified: xmlbeans/trunk/docs/guide/antXmlbean.html
URL: http://svn.apache.org/viewcvs/xmlbeans/trunk/docs/guide/antXmlbean.html?view=diff&r1=151275&r2=151276
==============================================================================
--- xmlbeans/trunk/docs/guide/antXmlbean.html (original)
+++ xmlbeans/trunk/docs/guide/antXmlbean.html Thu Feb  3 16:39:39 2005
@@ -1,5 +1,17 @@
 <!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><!-- InstanceBegin template="file:///C|/p4/main/help/ide/en/Templates/Command.dwt" codeOutsideHTMLIsLocked="false" -->
 <head>
 <!-- InstanceBeginEditable name="doctitle" -->

Modified: xmlbeans/trunk/docs/guide/conGettingStartedwithXMLBeans.html
URL: http://svn.apache.org/viewcvs/xmlbeans/trunk/docs/guide/conGettingStartedwithXMLBeans.html?view=diff&r1=151275&r2=151276
==============================================================================
--- xmlbeans/trunk/docs/guide/conGettingStartedwithXMLBeans.html (original)
+++ xmlbeans/trunk/docs/guide/conGettingStartedwithXMLBeans.html Thu Feb  3 16:39:39 2005
@@ -1,10 +1,22 @@
 <!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>Getting Started with XMLBeans</title>
-<!-- InstanceEndEditable --> 
+<!-- InstanceEndEditable -->
 <!--(Meta)==========================================================-->
 
 <meta http-equiv=Content-Type content="text/html; charset=$CHARSET;">
@@ -19,7 +31,7 @@
 <!-- InstanceEndEditable -->
 
 <!--(Links)=========================================================-->
-<!-- InstanceBeginEditable name="head" --> 
+<!-- InstanceBeginEditable name="head" -->
 <link href="../xmlbeans.css" rel="stylesheet" type="text/css">
 <!-- InstanceEndEditable -->
 <link href="../xmlbeans.css" rel="stylesheet" type="text/css">
@@ -34,64 +46,64 @@
 <script language="JavaScript">
 
 </script>
-<!-- InstanceBeginEditable name="body" --> 
+<!-- InstanceBeginEditable name="body" -->
 <h1> Getting Started with XMLBeans</h1>
-<div id="topictext"> 
-  <p>XMLBeans provides intuitive ways to handle XML that make it easier for you 
+<div id="topictext">
+  <p>XMLBeans provides intuitive ways to handle XML that make it easier for you
     to access and manipulate XML data and documents in Java. </p>
   <p>Characteristics of XMLBeans approach to XML:</p>
 </div>
 <ul>
-  <li> 
-    <div>It provides a familiar Java object-based view of XML data without losing 
+  <li>
+    <div>It provides a familiar Java object-based view of XML data without losing
       access to the original, native XML structure.</div>
   </li>
-  <li> 
-    <div>The XML's integrity as a document is not lost with XMLBeans. XML-oriented 
-      APIs commonly take the XML apart in order to bind to its parts. With XMLBeans, 
-      the entire XML instance document is handled as a whole. The XML data is 
-      stored in memory as XML. This means that the document order is preserved 
+  <li>
+    <div>The XML's integrity as a document is not lost with XMLBeans. XML-oriented
+      APIs commonly take the XML apart in order to bind to its parts. With XMLBeans,
+      the entire XML instance document is handled as a whole. The XML data is
+      stored in memory as XML. This means that the document order is preserved
       as well as the original element content with whitespace.</div>
   </li>
-  <li> 
-    <div>With types generated from schema, access to XML instances is through 
+  <li>
+    <div>With types generated from schema, access to XML instances is through
       JavaBean-like accessors, with get and set methods.</div>
   </li>
-  <li> 
-    <div>It is designed with XML schema in mind from the beginning &#8212; XMLBeans 
+  <li>
+    <div>It is designed with XML schema in mind from the beginning &#8212; XMLBeans
       supports all XML schema definitions.</div>
   </li>
   <li>Access to XML is fast.</li>
 </ul>
-<div> 
-  <p>The starting point for XMLBeans is XML schema. A schema (contained in an 
-    XSD file) is an XML document that defines a set of rules to which other XML 
-    documents must conform. The XML Schema specification provides a rich data 
-    model that allows you to express sophisticated structure and constraints on 
-    your data. For example, an XML schema can enforce control over how data is 
-    ordered in a document, or constraints on particular values (for example, a 
-    birth date that must be later than 1900). Unfortunately, the ability to enforce 
-    rules like this is typically not available in Java without writing custom 
+<div>
+  <p>The starting point for XMLBeans is XML schema. A schema (contained in an
+    XSD file) is an XML document that defines a set of rules to which other XML
+    documents must conform. The XML Schema specification provides a rich data
+    model that allows you to express sophisticated structure and constraints on
+    your data. For example, an XML schema can enforce control over how data is
+    ordered in a document, or constraints on particular values (for example, a
+    birth date that must be later than 1900). Unfortunately, the ability to enforce
+    rules like this is typically not available in Java without writing custom
     code. XMLBeans honors schema constraints.</p>
-  <p class="notepara"><strong>Note:</strong> Where an XML schema defines rules 
-    for an XML document, an XML <em>instance</em> is an XML document that conforms 
+  <p class="notepara"><strong>Note:</strong> Where an XML schema defines rules
+    for an XML document, an XML <em>instance</em> is an XML document that conforms
     to the schema.</p>
-  <p>You compile a schema (XSD) file to generate a set of Java interfaces that 
-    mirror the schema. With these types, you process XML instance documents that 
-    conform to the schema. You bind an XML instance document to these types; changes 
+  <p>You compile a schema (XSD) file to generate a set of Java interfaces that
+    mirror the schema. With these types, you process XML instance documents that
+    conform to the schema. You bind an XML instance document to these types; changes
     made through the Java interface change the underlying XML representation.</p>
-  <p>Previous options for handling XML include using XML programming interfaces 
-    (such as DOM or SAX) or an XML marshalling/binding tool (such as JAXB). Because 
-    it lacks strong schema-oriented typing, navigation in a DOM-oriented model 
-    is more tedious and requires an understanding of the complete object model. 
-    JAXB provides support for the XML schema specification, but handles only a 
-    subset of it; XMLBeans supports all of it. Also, by storing the data in memory 
+  <p>Previous options for handling XML include using XML programming interfaces
+    (such as DOM or SAX) or an XML marshalling/binding tool (such as JAXB). Because
+    it lacks strong schema-oriented typing, navigation in a DOM-oriented model
+    is more tedious and requires an understanding of the complete object model.
+    JAXB provides support for the XML schema specification, but handles only a
+    subset of it; XMLBeans supports all of it. Also, by storing the data in memory
     as XML, XMLBeans is able to reduce the overhead of marshalling and demarshalling.</p>
   <h1>Accessing XML Using Its Schema</h1>
-  <p>To get a glimpse of the kinds of things you can do with XMLBeans, take a 
-    look at an example using XML for a purchase order. The purchase order XML 
-    contains data exchanged by two parties, such as two companies. Both parties 
-    need to be able to rely on a consistent message shape, and a schema specifies 
+  <p>To get a glimpse of the kinds of things you can do with XMLBeans, take a
+    look at an example using XML for a purchase order. The purchase order XML
+    contains data exchanged by two parties, such as two companies. Both parties
+    need to be able to rely on a consistent message shape, and a schema specifies
     the common ground. </p>
   <p>Here's what a purchase order XML instance might look like.</p>
   <pre>
@@ -118,27 +130,27 @@
         &lt;po:per-ounce-rate&gt;0.74&lt;/po:per-ounce-rate&gt;
     &lt;/po:shipper&gt;
 &lt;/po:purchase-order&gt;</pre>
-  <p>This XML includes a root element, <span class="langinline">purchase-order</span>, 
-    that has three kinds of child elements: <span class="langinline">customer</span>, 
-    <span class="langinline">date</span>, <span class="langinline">line-item</span>, 
-    and <span class="langinline">shipper</span>. An intuitive, object-based view 
-    of this XML would provide an object representing the <span class="langinline">purchase-order</span> 
-    element, and it would have methods for getting the date and for getting subordinate 
-    objects for <span class="langinline">customer</span>, <span class="langinline">line-item</span>, 
-    and <span class="langinline">shipper</span> elements. Each of the last three 
+  <p>This XML includes a root element, <span class="langinline">purchase-order</span>,
+    that has three kinds of child elements: <span class="langinline">customer</span>,
+    <span class="langinline">date</span>, <span class="langinline">line-item</span>,
+    and <span class="langinline">shipper</span>. An intuitive, object-based view
+    of this XML would provide an object representing the <span class="langinline">purchase-order</span>
+    element, and it would have methods for getting the date and for getting subordinate
+    objects for <span class="langinline">customer</span>, <span class="langinline">line-item</span>,
+    and <span class="langinline">shipper</span> elements. Each of the last three
     would have its own methods for getting the data inside them as well.</p>
   <h2>Looking at the Schema</h2>
-  <p>The following XML is the the schema for the preceding purchase order XML. 
-    It defines the XML's &quot;shape&quot; &#8212; what its elements are, what 
+  <p>The following XML is the the schema for the preceding purchase order XML.
+    It defines the XML's &quot;shape&quot; &#8212; what its elements are, what
     order they appear in, which are children of which, and so on.</p>
 </div>
-<div> 
+<div>
   <pre>
 &lt;xs:schema targetNamespace="http://openuri.org/easypo"
     xmlns:po="http://openuri.org/easypo"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
     elementFormDefault="qualified"&gt;
-	
+
     &lt;xs:element name="purchase-order"&gt;
         &lt;xs:complexType&gt;
             &lt;xs:sequence&gt;
@@ -170,48 +182,48 @@
         &lt;/xs:sequence&gt;
     &lt;/xs:complexType&gt;
 &lt;/xs:schema&gt;</pre>
-  <div> 
+  <div>
     <p>This schema describes the purchase order XML instance by defining the following:</p>
   </div>
   <ul>
-    <li> 
-      <div>Definitions for three complex types &#8212; customer, line-item, and 
-        shipper. These are the types used for the children of the purchase-order 
-        element. In schema, a complex type is one that defines an element that 
-        may have child elements and attributes. The sequence element nested in 
+    <li>
+      <div>Definitions for three complex types &#8212; customer, line-item, and
+        shipper. These are the types used for the children of the purchase-order
+        element. In schema, a complex type is one that defines an element that
+        may have child elements and attributes. The sequence element nested in
         the complex type lists its child elements.</div>
-      <p>These are also <em>global</em> types. They are global because they are 
-        at the top level of the schema (in other words, just beneath the <span class="langinline">schema</span> 
-        root element). This means that they may be referenced from anywhere else 
+      <p>These are also <em>global</em> types. They are global because they are
+        at the top level of the schema (in other words, just beneath the <span class="langinline">schema</span>
+        root element). This means that they may be referenced from anywhere else
         in the schema.</p>
     </li>
   </ul>
 </div>
 <div>
   <ul>
-    <li>Use of simple types within the complex types. The name, address, and description 
-      elements (among others) are typed as simple types. As it happens, these 
-      are also <em>built-in</em> types. A built-in type (here, one with the &quot;xs&quot; 
-      prefix) is part of the schema specification. (The specification defines 
+    <li>Use of simple types within the complex types. The name, address, and description
+      elements (among others) are typed as simple types. As it happens, these
+      are also <em>built-in</em> types. A built-in type (here, one with the &quot;xs&quot;
+      prefix) is part of the schema specification. (The specification defines
       46 built-in types.)</li>
-    <li>A global element called purchase-order. This element definition includes 
-      a nested complex type definition that specifies the child elements for a 
-      purchase-order element. Notice that the complex type includes references 
+    <li>A global element called purchase-order. This element definition includes
+      a nested complex type definition that specifies the child elements for a
+      purchase-order element. Notice that the complex type includes references
       to the other complex types defined in this schema.</li>
   </ul>
   <div></div>
-  <p>In other words, the schema defines types for the child elements and describes 
+  <p>In other words, the schema defines types for the child elements and describes
     their position as subordinate to the root element, <span class="langinline">purchase-order</span>.</p>
-  <p>When you use the XMLBean compiler with an XSD file such as this one, you 
+  <p>When you use the XMLBean compiler with an XSD file such as this one, you
     generate a JAR file containing the interfaces generated from the schema.</p>
   <h2>Writing Java Code That Uses the Interfaces</h2>
-  <p>With the XMLBeans interfaces in your application, you can write code that 
-    uses the new types to handle XML based on the schema. Here's an example that 
-    extracts information about each of the ordered items in the purchase order 
-    XML, counts the items, and calculates a total of their prices. In particular, 
-    look at the use of types generated from the schema and imported as part of 
+  <p>With the XMLBeans interfaces in your application, you can write code that
+    uses the new types to handle XML based on the schema. Here's an example that
+    extracts information about each of the ordered items in the purchase order
+    XML, counts the items, and calculates a total of their prices. In particular,
+    look at the use of types generated from the schema and imported as part of
     the <span class="langinline">org.openuri.easypo</span> package. </p>
-  <p>The <span class="langinline">printItems</span> method receives a <span class="langinline">File</span> 
+  <p>The <span class="langinline">printItems</span> method receives a <span class="langinline">File</span>
     object containing the purchase order XML file.</p>
   <pre>
 package docs.xmlbeans;
@@ -222,18 +234,18 @@
 import org.openuri.easypo.PurchaseOrder;
 import org.openuri.easypo.LineItem;
 
-public class POHandler 
+public class POHandler
 {
-    public static void printItems(File po) throws Exception 
+    public static void printItems(File po) throws Exception
     {
         /*
          * All XMLBeans schema types provide a nested Factory class you can
          * use to bind XML to the type, or to create new instances of the type.
-         * Note that a "Document" type such as this one is an XMLBeans 
+         * Note that a "Document" type such as this one is an XMLBeans
          * construct for representing a global element. It provides a way
          * for you to get and set the contents of the entire element.
          *
-         * Also, note that the parse method will only succeed if the 
+         * Also, note that the parse method will only succeed if the
          * XML you're parsing appears to conform to the schema.
          */
         PurchaseOrderDocument poDoc =
@@ -247,11 +259,11 @@
 
         /*
          * When an element may occur more than once as a child element,
-         * the schema compiler will generate methods that refer to an 
+         * the schema compiler will generate methods that refer to an
          * array of that element. The line-item element is defined with
-         * a maxOccurs attribute value of "unbounded", meaning that 
+         * a maxOccurs attribute value of "unbounded", meaning that
          * it may occur as many times in an instance document as needed.
-         * So there are methods such as getLineItemArray and setLineItemArray. 
+         * So there are methods such as getLineItemArray and setLineItemArray.
          */
         LineItem[] lineitems = po.getLineItemArray();
         System.out.println("Purchase order has " + lineitems.length + " line items.");
@@ -260,11 +272,11 @@
         int numberOfItems = 0;
 
         /*
-         * Loop through the line-item elements, using generated accessors to 
+         * Loop through the line-item elements, using generated accessors to
          * get values for child elements such a description, quantity, and
          * price.
          */
-        for (int j = 0; j < lineitems.length; j++) 
+        for (int j = 0; j < lineitems.length; j++)
         {
             System.out.println(" Line item: " + j);
             System.out.println(
@@ -282,30 +294,30 @@
   <p>Notice that types generated from the schema reflect what's in the XML:</p>
 </div>
 <ul>
-  <li> 
-    <div>A <span class="langinline">PurchaseOrderDocument</span> represents the 
+  <li>
+    <div>A <span class="langinline">PurchaseOrderDocument</span> represents the
       global root element.</div>
   </li>
-  <li> 
-    <div>A <span class="langinline">getPurchaseOrder</span> method returns a <span class="langinline">PurchaseOrderDocument.PurchaseOrder</span> 
-      type that contains child elements, including <span class="langinline">line-item</span>. 
-      A <span class="langinline">getLineItemArray</span> method returns a <span class="langinline">LineItem</span> 
+  <li>
+    <div>A <span class="langinline">getPurchaseOrder</span> method returns a <span class="langinline">PurchaseOrderDocument.PurchaseOrder</span>
+      type that contains child elements, including <span class="langinline">line-item</span>.
+      A <span class="langinline">getLineItemArray</span> method returns a <span class="langinline">LineItem</span>
       array containing the <span class="langinline">line-item</span> elements.</div>
   </li>
-  <li>Other methods, such as <span class="langinline">getQuantity</span>, <span class="langinline">getPrice</span>, 
-    and so on, follow naturally from what the schema describes, returning corresponding 
+  <li>Other methods, such as <span class="langinline">getQuantity</span>, <span class="langinline">getPrice</span>,
+    and so on, follow naturally from what the schema describes, returning corresponding
     children of the <span class="langinline">line-item</span> element.</li>
-  <li>The name of the package containing these types is derived from the schema's 
+  <li>The name of the package containing these types is derived from the schema's
     target namespace.</li>
 </ul>
-<div> 
-  <p>Capitalization and punctuation for generated type names follow Java convention. 
-    Also, while this example parses the XML from a file, other <span class="langinline">parse</span> 
-    methods support a Java <span class="langinline">InputStream</span> object, 
+<div>
+  <p>Capitalization and punctuation for generated type names follow Java convention.
+    Also, while this example parses the XML from a file, other <span class="langinline">parse</span>
+    methods support a Java <span class="langinline">InputStream</span> object,
     a <span class="langinline">Reader</span> object, and so on.</p>
   <p>The preceding Java code prints the following to the console:</p>
 </div>
-<div> 
+<div>
   <pre>
 Purchase order has 3 line items.
  Line item 0
@@ -319,11 +331,11 @@
 Total items: 4
 Total amount: 41.68</pre>
   <h2>Creating New XML Instances from Schema</h2>
-  <p>As you've seen XMLBeans provides a &quot;factory&quot; class you can use 
-    to create new instances. The following example creates a new <span class="langinline">purchase-order</span> 
-    element and adds a <span class="langinline">customer</span> child element. 
-    It then inserts <span class="langinline">name</span> and <span class="langinline">address</span> 
-    child elements, creating the elements and setting their values with a single 
+  <p>As you've seen XMLBeans provides a &quot;factory&quot; class you can use
+    to create new instances. The following example creates a new <span class="langinline">purchase-order</span>
+    element and adds a <span class="langinline">customer</span> child element.
+    It then inserts <span class="langinline">name</span> and <span class="langinline">address</span>
+    child elements, creating the elements and setting their values with a single
     call to their <span class="langinline">set</span> methods.</p>
   <pre>
 public PurchaseOrderDocument createPO()
@@ -336,10 +348,10 @@
 &nbsp;&nbsp;&nbsp;&nbsp;return newPODoc;
 }
 </pre>
-  <p>The following is the XML that results. Note that XMLBeans assigns the correct 
-    namespace based on the schema, using an &quot;ns1&quot; (or, &quot;namespace 
-    1&quot;) prefix. For practical purposes, the prefix itself doesn't really 
-    matter &#8212; it's the namespace URI (http://openuri.org/easypo) that defines 
+  <p>The following is the XML that results. Note that XMLBeans assigns the correct
+    namespace based on the schema, using an &quot;ns1&quot; (or, &quot;namespace
+    1&quot;) prefix. For practical purposes, the prefix itself doesn't really
+    matter &#8212; it's the namespace URI (http://openuri.org/easypo) that defines
     the namespace. The prefix is merely a marker that represents it.</p>
   <pre>&lt;ns1:purchase-order xmlns:ns1=&quot;http://openuri.org/easypo&quot;&gt;
 &nbsp;&nbsp;&nbsp;&nbsp;&lt;ns1:customer&gt;
@@ -348,39 +360,39 @@
 &nbsp;&nbsp;&nbsp;&nbsp;&lt;/ns1:customer&gt;
 &lt;/ns1:purchase-order&gt;
 </pre>
-  <p>Note that all types (including those generated from schema) inherit from 
-    <span class="langinline">XmlObject</span>, and so provide a <span class="langinline">Factory</span> 
-    class. For an overview of the type system in which <span class="langinline">XmlObject</span> 
-    fits, see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans Support 
-    for Built-In Schema Types</a>. For reference information, see <a href="../reference/org/apache/xmlbeans/XmlObject.html">XmlObject 
+  <p>Note that all types (including those generated from schema) inherit from
+    <span class="langinline">XmlObject</span>, and so provide a <span class="langinline">Factory</span>
+    class. For an overview of the type system in which <span class="langinline">XmlObject</span>
+    fits, see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans Support
+    for Built-In Schema Types</a>. For reference information, see <a href="../reference/org/apache/xmlbeans/XmlObject.html">XmlObject
     Interface</a>.</p>
   <h1>XMLBeans Hierarchy</h1>
-  <p>The generated types you saw used in the preceding example are actually part 
-    of a hierarchy of XMLBeans types. This hierarchy is one of the ways in which 
-    XMLBeans presents an intuitive view of schema. At the top of the hierarchy 
-    is <span class="langinline">XmlObject</span>, the base interface for XMLBeans 
-    types. Beneath this level, there are two main type categories: generated types 
-    that represent user-derived schema types, and included types that represent 
+  <p>The generated types you saw used in the preceding example are actually part
+    of a hierarchy of XMLBeans types. This hierarchy is one of the ways in which
+    XMLBeans presents an intuitive view of schema. At the top of the hierarchy
+    is <span class="langinline">XmlObject</span>, the base interface for XMLBeans
+    types. Beneath this level, there are two main type categories: generated types
+    that represent user-derived schema types, and included types that represent
     built-in schema types.</p>
-  This topic has already introduced generated types. For more information, see 
-  <a href="conJavaTypesGeneratedFromUserDerived.html">Java Types Generated from 
-  User-Derived Schema Types.</a> 
+  This topic has already introduced generated types. For more information, see
+  <a href="conJavaTypesGeneratedFromUserDerived.html">Java Types Generated from
+  User-Derived Schema Types.</a>
   <h2>Built-In Type Support</h2>
-  <p>In addition to types generated from a given schema, XMLBeans provides 46 
-    Java types that mirror the 46 built-in types defined by the XML schema specification. 
-    Where schema defines <span class="langinline">xs:string</span>, <span class="langinline">xs:decimal</span>, 
-    and <span class="langinline">xs:int</span>, for example, XMLBeans provides 
-    <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlString.html">XmlString</a></span>, 
-    <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlDecimal.html">XmlDecimal</a></span>, 
-    and <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlInt.html">XmlInt</a></span>. 
-    Each of these also inherits from <span class="langinline">XmlObject</span>, 
+  <p>In addition to types generated from a given schema, XMLBeans provides 46
+    Java types that mirror the 46 built-in types defined by the XML schema specification.
+    Where schema defines <span class="langinline">xs:string</span>, <span class="langinline">xs:decimal</span>,
+    and <span class="langinline">xs:int</span>, for example, XMLBeans provides
+    <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlString.html">XmlString</a></span>,
+    <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlDecimal.html">XmlDecimal</a></span>,
+    and <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlInt.html">XmlInt</a></span>.
+    Each of these also inherits from <span class="langinline">XmlObject</span>,
     which corresponds to the built-in schema type <span class="langinline">xs:anyType</span>.</p>
-  <p>XMLBeans provides a way for you to handle XML data as these built-in types. 
-    Where your schema includes an element whose type is, for example, <span class="langinline">xs:int</span>, 
-    XMLBeans will provide a generated method designed to return an <span class="langinline">XmlInt</span>. 
-    In addition, as you saw in the preceding example, for most types there will 
-    also be a method that returns a natural Java type such as <span class="langinline">int</span>. 
-    The following two lines of code return the <span class="langinline">quantity</span> 
+  <p>XMLBeans provides a way for you to handle XML data as these built-in types.
+    Where your schema includes an element whose type is, for example, <span class="langinline">xs:int</span>,
+    XMLBeans will provide a generated method designed to return an <span class="langinline">XmlInt</span>.
+    In addition, as you saw in the preceding example, for most types there will
+    also be a method that returns a natural Java type such as <span class="langinline">int</span>.
+    The following two lines of code return the <span class="langinline">quantity</span>
     element's value, but return it as different types.</p>
   <pre>
 // Methods that return simple types begin with an "x".
@@ -388,26 +400,26 @@
 // Methods that return a natural Java type are unadorned.
 int javaQuantity = lineitems[j].getQuantity();
 </pre>
-  <p>In a sense both get methods navigate to the <span class="langinline">quantity</span> 
-    element; the <span class="langinline">getQuantity</span> method goes a step 
-    further and converts the elements value to the most appropriate natural Java 
-    type before returning it. (XMLBeans also provides a means for validating the 
+  <p>In a sense both get methods navigate to the <span class="langinline">quantity</span>
+    element; the <span class="langinline">getQuantity</span> method goes a step
+    further and converts the elements value to the most appropriate natural Java
+    type before returning it. (XMLBeans also provides a means for validating the
     XML as you work with it.)</p>
-  <p>If you know a bit about XML schema, XMLBeans types should seem fairly intuitive. 
-    If you don't, you'll learn a lot by experimenting with XMLBeans using your 
+  <p>If you know a bit about XML schema, XMLBeans types should seem fairly intuitive.
+    If you don't, you'll learn a lot by experimenting with XMLBeans using your
     own schemas and XML instances based on them. </p>
-  <p>For more information on the methods of types generated from schema, see <a href="conMethodsForGeneratedJavaTypes.html">Methods 
-    for Types Generated From Schema</a>. For more about the how XMLBeans represents 
-    built-in schema types, see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans 
+  <p>For more information on the methods of types generated from schema, see <a href="conMethodsForGeneratedJavaTypes.html">Methods
+    for Types Generated From Schema</a>. For more about the how XMLBeans represents
+    built-in schema types, see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans
     Support for Built-In Schema Types</a>.</p>
   <h1>Using XQuery Expressions</h1>
-  <p>With XMLBeans you can use XQuery to query XML for specific pieces of data. 
-    XQuery is sometimes referred to as &quot;SQL for XML&quot; because it provides 
-    a mechanism to access data directly from XML documents, much as SQL provides 
+  <p>With XMLBeans you can use XQuery to query XML for specific pieces of data.
+    XQuery is sometimes referred to as &quot;SQL for XML&quot; because it provides
+    a mechanism to access data directly from XML documents, much as SQL provides
     a mechanism for accessing data in traditional databases.</p>
-  <p>XQuery borrows some of its syntax from XPath, a syntax for specifying nested 
-    data in XML. The following example returns all of the <span class="langinline">line-item</span> 
-    elements whose <span class="langinline">price</span> child elements have values 
+  <p>XQuery borrows some of its syntax from XPath, a syntax for specifying nested
+    data in XML. The following example returns all of the <span class="langinline">line-item</span>
+    elements whose <span class="langinline">price</span> child elements have values
     less than or equal to 20.00:</p>
   <pre>
 PurchaseOrderDocument doc = PurchaseOrderDocument.Factory.parse(po);
@@ -425,34 +437,34 @@
 XmlCursor itemCursor = doc.newCursor().execQuery(queryText);
 System.out.println(itemCursor.xmlText());
 </pre>
-  <p>This code creates a new cursor at the start of the document. From there, 
-    it uses the <span class="langinline">XmlCursor</span> interface's <span class="langinline">execQuery</span> 
-    method to execute the query expression. In this example, the method's parameter 
-    is an XQuery expression that simply says, &quot;From my current location, 
-    navigate through the <span class="langinline">purchase-order</span> element 
-    and retrieve those <span class="langinline">line-item</span> elements whose 
-    value is less than or equal to 20.00.&quot; The <span class="langinline">$this</span> 
+  <p>This code creates a new cursor at the start of the document. From there,
+    it uses the <span class="langinline">XmlCursor</span> interface's <span class="langinline">execQuery</span>
+    method to execute the query expression. In this example, the method's parameter
+    is an XQuery expression that simply says, &quot;From my current location,
+    navigate through the <span class="langinline">purchase-order</span> element
+    and retrieve those <span class="langinline">line-item</span> elements whose
+    value is less than or equal to 20.00.&quot; The <span class="langinline">$this</span>
     variable means &quot;the current position.&quot;</p>
-  <p>For more information about XQuery, see <a href="http://www.w3.org/TR/xquery/" target="_blank">XQuery 
+  <p>For more information about XQuery, see <a href="http://www.w3.org/TR/xquery/" target="_blank">XQuery
     1.0: An XML Query Language</a> at the W3C web site.</p>
   <h2>Using XML Cursors</h2>
-  <p>In the preceding example you may have noticed the <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlCursor.html">XmlCursor</a></span> 
-    interface. In addition to providing a way to execute XQuery expression, an 
-    XML cursors offers a fine-grained model for manipulating data. The XML cursor 
-    API, analogous to the DOM's object API, is simply a way to point at a particular 
-    piece of data. So, just like a cursor helps navigate through a word processing 
-    document, the XML cursor defines a location in XML where you can perform actions 
+  <p>In the preceding example you may have noticed the <span class="langinline"><a href="../reference/org/apache/xmlbeans/XmlCursor.html">XmlCursor</a></span>
+    interface. In addition to providing a way to execute XQuery expression, an
+    XML cursors offers a fine-grained model for manipulating data. The XML cursor
+    API, analogous to the DOM's object API, is simply a way to point at a particular
+    piece of data. So, just like a cursor helps navigate through a word processing
+    document, the XML cursor defines a location in XML where you can perform actions
     on the selected XML.</p>
-  <p>Cursors are ideal for moving through an XML document when there's no schema 
-    available. Once you've got the cursor at the location you're interested in, 
-    you can perform a variety of operations with it. For example, you can set 
-    and get values, insert and remove fragments of XML, copy fragments of XML 
-    to other parts of the document, and make other fine-grained changes to the 
+  <p>Cursors are ideal for moving through an XML document when there's no schema
+    available. Once you've got the cursor at the location you're interested in,
+    you can perform a variety of operations with it. For example, you can set
+    and get values, insert and remove fragments of XML, copy fragments of XML
+    to other parts of the document, and make other fine-grained changes to the
     XML document.</p>
-  <p>The following example uses an XML cursor to navigate to the <span class="langinline">customer</span> 
+  <p>The following example uses an XML cursor to navigate to the <span class="langinline">customer</span>
     element's <span class="langinline">name</span> child element.</p>
   <pre>
-PurchaseOrderDocument doc = 
+PurchaseOrderDocument doc =
     PurchaseOrderDocument.Factory.parse(po);
 
 XmlCursor cursor = doc.newCursor();
@@ -463,55 +475,55 @@
 
 cursor.dispose();
 </pre>
-  <p>What's happening here? As with the earlier example, the code loads the XML 
-    from a <span class="langinline">File</span> object. After loading the document, 
-    the code creates a cursor at its beginning. Moving the cursor a few times 
-    takes it to the nested <span class="langinline">name </span> element. Once 
+  <p>What's happening here? As with the earlier example, the code loads the XML
+    from a <span class="langinline">File</span> object. After loading the document,
+    the code creates a cursor at its beginning. Moving the cursor a few times
+    takes it to the nested <span class="langinline">name </span> element. Once
     there, the getText method retrieves the element's value.</p>
-  <p>This is just an introduction to XML cursors. For more information about using 
-    cursors, see <a href="conNavigatingXMLwithCursors.html">Navigating XML with 
+  <p>This is just an introduction to XML cursors. For more information about using
+    cursors, see <a href="conNavigatingXMLwithCursors.html">Navigating XML with
     Cursors</a>.</p>
   <h2>Where to Go Next</h2>
 </div>
 <ul>
-  <li> 
-    <div>XMLBeans provides intuitive ways to handle XML, particularly if you're 
-      starting with schema. If you're accessing XML that's based on a schema, 
-      you'll probably find it most efficient to access the XML through generated 
-      types specific to the schema. To do this, you begin by compiling the schema 
-      to generate interfaces. For more information on using XMLBeans types generated 
-      by compiling schema, see <a href="conJavaTypesGeneratedFromUserDerived.html">Java 
-      Types Generated From User-Derived Schema Types</a> and <a href="conMethodsForGeneratedJavaTypes.html">Methods 
+  <li>
+    <div>XMLBeans provides intuitive ways to handle XML, particularly if you're
+      starting with schema. If you're accessing XML that's based on a schema,
+      you'll probably find it most efficient to access the XML through generated
+      types specific to the schema. To do this, you begin by compiling the schema
+      to generate interfaces. For more information on using XMLBeans types generated
+      by compiling schema, see <a href="conJavaTypesGeneratedFromUserDerived.html">Java
+      Types Generated From User-Derived Schema Types</a> and <a href="conMethodsForGeneratedJavaTypes.html">Methods
       for Types Generated From Schema</a>.</div>
   </li>
-  <li> 
-    <div>You might be interested in reading more about the type system on which 
-      XMLBeans is based, particularly if you're using types generated from schema. 
-      XMLBeans provides a hierarchical system of types that mirror what you find 
-      in the XML schema specification itself. If you're working with schema, you 
-      might find it helps to understand how these types work. For more information, 
-      see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans Support 
-      for Built-In Schema Types</a> and <a href="conIntroToTheSchemaTypeSystem.html">Introduction 
+  <li>
+    <div>You might be interested in reading more about the type system on which
+      XMLBeans is based, particularly if you're using types generated from schema.
+      XMLBeans provides a hierarchical system of types that mirror what you find
+      in the XML schema specification itself. If you're working with schema, you
+      might find it helps to understand how these types work. For more information,
+      see <a href="conXMLBeansSupportBuiltInSchemaTypes.html">XMLBeans Support
+      for Built-In Schema Types</a> and <a href="conIntroToTheSchemaTypeSystem.html">Introduction
       to Schema Type Signatures</a>.</div>
   </li>
-  <li> 
-    <div>XMLBeans provides access to XML through XQuery, which borrows path syntax 
-      from XPath. With XQuery, you can specify specific fragments of XML data 
-      with or without schema. To learn more about using XQuery and XPath in XMLBeans, 
-      see <a href="conSelectingXMLwithXQueryPathXPath.html">Selecting XML with 
+  <li>
+    <div>XMLBeans provides access to XML through XQuery, which borrows path syntax
+      from XPath. With XQuery, you can specify specific fragments of XML data
+      with or without schema. To learn more about using XQuery and XPath in XMLBeans,
+      see <a href="conSelectingXMLwithXQueryPathXPath.html">Selecting XML with
       XQuery and XPath</a>.</div>
   </li>
-  <li>You can use the <span class="langinline">XmlCursor</span> interface for 
-    fine-grained navigation and manipulation of XML. For more information, see 
+  <li>You can use the <span class="langinline">XmlCursor</span> interface for
+    fine-grained navigation and manipulation of XML. For more information, see
     <a href="conNavigatingXMLwithCursors.html">Navigating XML with Cursors</a>.</li>
 </ul>
 <div>
-  <p class="notepara"><strong>Note:</strong> The xbean.jar file that contains 
+  <p class="notepara"><strong>Note:</strong> The xbean.jar file that contains
     the XMLBeans library is fully functional as a standalone library.</p>
   <h1>Related Topics</h1>
   <p><a href="../../samples/navXMLBeansSamples.html">XMLBeans Samples</a></p>
 </div>
-<!-- InstanceEndEditable --> 
+<!-- InstanceEndEditable -->
 <script language="JavaScript">
 
 </script>

Modified: xmlbeans/trunk/docs/guide/conIntroToTheSchemaTypeSystem.html
URL: http://svn.apache.org/viewcvs/xmlbeans/trunk/docs/guide/conIntroToTheSchemaTypeSystem.html?view=diff&r1=151275&r2=151276
==============================================================================
--- xmlbeans/trunk/docs/guide/conIntroToTheSchemaTypeSystem.html (original)
+++ xmlbeans/trunk/docs/guide/conIntroToTheSchemaTypeSystem.html Thu Feb  3 16:39:39 2005
@@ -1,10 +1,23 @@
 <!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 --> 
+<!-- InstanceEndEditable -->
 <!--(Meta)==========================================================-->
 
 <meta http-equiv=Content-Type content="text/html; charset=$CHARSET;">
@@ -19,7 +32,7 @@
 <!-- InstanceEndEditable -->
 
 <!--(Links)=========================================================-->
-<!-- InstanceBeginEditable name="head" --> 
+<!-- InstanceBeginEditable name="head" -->
 <link href="../xmlbeans.css" rel="stylesheet" type="text/css">
 <!-- InstanceEndEditable -->
 <link href="../xmlbeans.css" rel="stylesheet" type="text/css">
@@ -34,143 +47,143 @@
 <script language="JavaScript">
 
 </script>
-<!-- InstanceBeginEditable name="body" --> 
+<!-- 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 
+<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 &quot;meta-API,&quot; 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 
+  <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 &quot;meta-API,&quot; 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 &quot;Signatures&quot;</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 &quot;signature&quot; to describe each type. You can retrieve 
-    this signature by calling the SchemaType class's <span class="langinline">toString</span> 
+  <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 &quot;signature&quot; 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>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 &#8212; 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 
+  <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 &#8212; 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 
+  <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> 
+    <div>
+      <div>
         <pre>T=&lt;localname&gt;@&lt;targetNamespace&gt;</pre>
       </div>
     </div>
-    <p>The &quot;T&quot; is for &quot;type,&quot; of course. &quot;localname&quot; 
-      is a convention used by qnames (qualified names), which include a local 
+    <p>The &quot;T&quot; is for &quot;type,&quot; of course. &quot;localname&quot;
+      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 &lt;element&gt; or &lt;attribute&gt; 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> 
+  <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 &lt;element&gt; or &lt;attribute&gt; 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=&lt;document-element-name&gt;@&lt;targetNamespace&gt;
 R=&lt;attribute-type-name&gt;@&lt;targetNamespace&gt;
 </pre>
       <div></div>
     </div>
-    <div> 
-      <div>Note that these are also the signatures of a type returned by a FooDocument.type 
+    <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 
+  <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=&quot;qualified&quot;</span> 
+      <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=&quot;qualified&quot;</span>
           (the usual default):</p>
       </li>
     </ul>
   </li>
-  <blockquote> 
-    <div> 
+  <blockquote>
+    <div>
       <pre>E=&lt;eltname&gt;|&lt;signature of the type within which the elt is defined&gt;</pre>
     </div>
     <div>If the element is <span class="langinline" style="langinline">form=&quot;unqualified&quot;</span>:</div>
-    <div> 
+    <div>
       <pre>U=&lt;eltname&gt;|&lt;signature of the type within which the elt is defined&gt;</pre>
     </div>
-    <div>If the attribute is <span class="langinline" style="langline">form=&quot;unqualified&quot;</span> 
+    <div>If the attribute is <span class="langinline" style="langline">form=&quot;unqualified&quot;</span>
       (the usual default):</div>
-    <div> 
+    <div>
       <pre>A=&lt;attrname&gt;|&lt;signature of the type within the attr is defined&gt;</pre>
     </div>
     <div>if the attribute is <span class="langinline" style="langinline">form=&quot;qualified&quot;</span>:</div>
-    <div> 
+    <div>
       <pre>Q=&lt;attrname&gt;|&lt;signature of the type within the attr is defined&gt;</pre>
     </div>
   </blockquote>
   <ul>
-    <li>It might be an anonymous type defined a simple restriction, union, or 
+    <li>It might be an anonymous type defined a simple restriction, union, or
       list definition:</li>
   </ul>
-  <blockquote> 
-    <div> 
+  <blockquote>
+    <div>
       <pre>M=#|&lt;signature of the containing union type&gt;</pre>
-      <p>(The # is a number indicating which union member it is, by source order 
+      <p>(The # is a number indicating which union member it is, by source order
         &#8212; such as 0,1,2, etc.)</p>
       <pre>B=|&lt;signature of the containing base type for a restriction&gt;</pre>
       <pre>I=|&lt;signature of the containing list type&gt;</pre>
     </div>
   </blockquote>
   <ul>
-    <li> 
-      <div> In the future if anonymous types are allowed in some other context, 
+    <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 
+<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> 
+<blockquote>
+  <div>
     <pre> &lt;root mylist=&quot;432 999 143 123&quot;/&gt;</pre>
   </div>
 </blockquote>
-<div> The schema, if done with lots of nested types, could look something like 
+<div> The schema, if done with lots of nested types, could look something like
   this:</div>
 <blockquote>
   <div>
@@ -191,24 +204,24 @@
 <blockquote>
   <pre>I=|A=mylist|E=root|D=root@myNamespace</pre>
 </blockquote>
-<div> 
+<div>
   <p>You could read this as: </p>
 </div>
 <blockquote>
-  <div>&quot;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 
+  <div>&quot;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
     &lt;root&gt; documents | in the myNamespace namespace&quot;.</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 
+<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 --> 
+<!-- InstanceEndEditable -->
 <script language="JavaScript">
 
 </script>



---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@xmlbeans.apache.org
For additional commands, e-mail: commits-help@xmlbeans.apache.org


Mime
View raw message