samples/Any/src/org/apache/xmlbeans/samples/anytype/Any.java - xmlbeans - Git at Google

 /*   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.
  */

 package org.apache.xmlbeans.samples.anytype;

 import org.apache.xmlbeans.*;
 import org.apache.xmlbeans.samples.any.ListOfStrings;
 import org.apache.xmlbeans.samples.any.RootDocument;
 import org.apache.xmlbeans.samples.any.StringelementDocument;
 import org.apache.xmlbeans.samples.any.RootDocument.Root.Arrayofany;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Iterator;

 import javax.xml.namespace.QName;

 /**
  * A sample that illustrates various ways to manipulate XML whose
  * schema defines elements as type xs:any. Unlike its treatment of
  * other schema types, XMLBeans does not generate accessors for the
  * xs:any particle when compiling schema. Instead, your code
  * handles instances of this type through any of several alternative
  * means, including XPath queries, the selectChildren method,
  * XmlCursor instances and the DOM API. This samples illustrates
  * these alternative approaches.
  */
 public class Any
 {
     private static final String m_namespaceUri = "http://xmlbeans.apache.org/samples/any";

     /**
      * Receives <root> XML instance, executing methods that
      * edit the received instance or create a new one.
      *
      * @param args An array in which the first item is a
      * path to the XML instance file.
      */
     public static void main(String[] args)
     {
         Any thisSample = new Any();
         System.out.println("Running Any.buildDocFromScratch\n");
         thisSample.buildDocFromScratch();

         RootDocument rootDoc = (RootDocument)thisSample.parseXml(args[0]);

         System.out.println("Running Any.editExistingDocWithSelectChildren\n");
         thisSample.editExistingDocWithSelectChildren(rootDoc);

         System.out.println("Running Any.editExistingDocWithDOM\n");
         thisSample.editExistingDocWithDOM(rootDoc);

         System.out.println("Running Any.editExistingDocWithSelectPath\n");
         thisSample.editExistingDocWithSelectPath(rootDoc);
     }

     /**
      * Creates a new <root> document from scratch.
      *
      * This method illustrates how you can use XmlCursor instances
      * to build XML that is defined in schema as xs:any.
      *
      * @return <code>true</code> if the new document is valid;
      * otherwise, <code>false</code>.
      */
     public boolean buildDocFromScratch()
     {
         // Start by creating a <root> element that will contain
         // the children built by this method.
         RootDocument rootDoc = RootDocument.Factory.newInstance();
         RootDocument.Root root = rootDoc.addNewRoot();

         // Add the first element, <stringelement>.
         root.setStringelement("some text");

         // Create an XmlObject in which to build the second
         // element in the sequence, <anyfoo>. Here, the
         // XmlObject instance is simply a kind of incubator
         // for the XML. Later the XML will be moved into the
         // document this code is building.
         XmlObject anyFoo = XmlObject.Factory.newInstance();

         // Add a cursor to do the work of building the XML.
         XmlCursor childCursor = anyFoo.newCursor();
         childCursor.toNextToken();

         // Add the element in the schema's namespace, then add
         // element content.
         childCursor.beginElement(new QName(m_namespaceUri, "anyfoo"));
         childCursor.insertChars("some text");

         // Move the cursor back to the new element's top, where
         // it can grab the element's XML.
         childCursor.toStartDoc();
         childCursor.toNextToken();

         // Move the XML into the <root> document by moving it
         // from a position at one cursor to a position at
         // another.
         XmlCursor rootCursor = root.newCursor();
         rootCursor.toEndToken();
         childCursor.moveXml(rootCursor);

         // Add the fourth element, <arrayofany>, by building it
         // elsewhere, then moving the new XML into place under
         // <root>.
         Arrayofany arrayOfAny = root.addNewArrayofany();
         if (buildArrayOfAny(arrayOfAny) == null)
         {
             return false;
         }

         childCursor.dispose();
         rootCursor.dispose();

         // Print and validate the result.
         System.out.println("Output: The <root> document built from scratch.\n");
         System.out.println(rootDoc + "\n");
         return validateXml(rootDoc);
     }

     /**
      * Replaces the <anyfoo> element with an <anybar> element in the
      * incoming XML.
      *
      * This method illustrates how you can use the XmlCursor.selectChildren
      * method to retrieve child elements whose type is defined as
      * xs:any in schema.
      *
      * @param rootDoc An instance of the <root> XML document.
      * @return <code>true</code> if the editing XML is valid;
      * otherwise, <code>false</code>.
      */
     public boolean editExistingDocWithSelectChildren(RootDocument rootDoc)
     {
         RootDocument.Root root = rootDoc.getRoot();

         // Select the <anyfoo> children of <root>.
         XmlObject[] stringElements =
             root.selectChildren(new QName(m_namespaceUri, "anyfoo"));

         // If the element is there, replace it with another element.
         if (stringElements.length > 0)
         {
             XmlCursor editCursor = stringElements[0].newCursor();
             editCursor.removeXml();
             editCursor.beginElement(new QName(m_namespaceUri, "anybar"));
             editCursor.insertChars("some other text");
             editCursor.dispose();
         }
         System.out.println("Output: The <anyfoo> element has been replaced\n" +
         		"by an <anybar> element.\n");
         System.out.println(rootDoc + "\n");
         return validateXml(rootDoc);
     }

     /**
      * Adds a new <bar> element between the first and second
      * children of the <arrayofany> element.
      *
      * This method illustrates how you can use DOM methods to
      * retrieve and edit elements whose type is defined as
      * xs:any in schema.
      *
      * @param rootDoc An instance of the <root> XML document.
      * @return <code>true</code> if the editing XML is valid;
      * otherwise, <code>false</code>.
      */
     public boolean editExistingDocWithDOM(RootDocument rootDoc)
     {
         RootDocument.Root root = rootDoc.getRoot();

         // Get the DOM nodes for the <arrayofany> element's children.
         Node arrayOfAnyNode = root.getArrayofany().getDomNode();

         // You don't have get* accessors for any of the <arrayofany>
         // element's children, so use DOM to identify the first
         // and second elements while looping through the child list.
         NodeList childList = arrayOfAnyNode.getChildNodes();
         Element firstElementChild = null;
         Element secondElementChild = null;

         // Find the first child element and make sure it's
         // <stringelement>.
         for (int i = 0; i < childList.getLength(); i++)
         {
             Node node = childList.item(i);
             if (node.getNodeType() == Node.ELEMENT_NODE)
             {
                 if (node.getLocalName().equals("stringelement"))
                 {
                     firstElementChild = (Element)node;
                     break;
                 }
             }
         }
         if (firstElementChild == null) {return false;}

         // Find the second child element and make sure it's
         // <someelement>.
         Node node = firstElementChild.getNextSibling();
         do {
             if (node.getNodeType() == Node.ELEMENT_NODE)
             {
                 if (node.getLocalName().equals("someelement"))
                 {
                     secondElementChild = (Element)node;
                     break;
                 }
             }
             node = node.getNextSibling();
         } while (node != null);
         if (secondElementChild == null) {return false;}

         // Create and insert a new <bar> element.
         Element fooElement =
             secondElementChild.getOwnerDocument().createElementNS("http://openuri.org","bar");
         Node valueNode =
             fooElement.getOwnerDocument().createTextNode("some text");
         fooElement.appendChild(valueNode);
         arrayOfAnyNode.insertBefore(fooElement, secondElementChild);

         System.out.println("Output: <arrayofany> has a new <bar> child element.\n");
         System.out.println(rootDoc + "\n");
         return validateXml(rootDoc);
     }

     /**
      * Edits incoming <root> XML to make the following changes: replace
      * <somelement> with its <stringlist> child; add a new <foo>
      * element as the second child of <arrayofany>.
      *
      * This method illustrates how you can use the selectPath method
      * to find an element defined as xs:any in schema, then use
      * XmlCursor instances to edit the XML.
      *
      * @param rootDoc An instance of the <root> XML document.
      * @return <code>true</code> if the editing XML is valid;
      * otherwise, <code>false</code>.
      */
     public boolean editExistingDocWithSelectPath(RootDocument rootDoc)
     {
         String namespaceDecl = "declare namespace any='" +
         			m_namespaceUri + "'; ";
         XmlCursor selectionCursor = rootDoc.getRoot().getArrayofany().newCursor();

         // Save the cursor's position for later, then use XPath
         // and cursor movement to position the cursor at
         // the <stringlist> element.
         selectionCursor.push();
         selectionCursor.selectPath(namespaceDecl +
                 "$this//any:someelement/any:stringlist");
         selectionCursor.toNextSelection();

         // Create a new cursor and move it to the selection
         // cursor's <someelement> parent. Moving the
         // <stringlist> element to this position, displacing
         // the <someelement> downward, then removing the
         // <someelement> XML effectively replaces <someelement>
         // with <stringlist>.
         XmlCursor editCursor = selectionCursor.newCursor();
         editCursor.toParent();
         selectionCursor.moveXml(editCursor);
         editCursor.removeXml();
         editCursor.dispose();

         // Return the cursor to the <arrayofany> element so you
         // can do more editing. Then move the cursor to the second
         // child and insert a new element as second child.
         selectionCursor.pop();
         selectionCursor.toFirstChild();
         selectionCursor.toNextSibling();
         selectionCursor.beginElement("foo", "http://openuri.org");
         selectionCursor.insertChars("some text");
         selectionCursor.dispose();

         System.out.println("Output: <stringlist> has been promoted to replace \n" +
                 "<someelement>, and there's a new <foo> element.\n");
         System.out.println(rootDoc + "\n");
         return validateXml(rootDoc);
     }

     /**
      * Like the code in the buildDocFromScratch method, this code
      * uses the XmlCursor to build XML piece by piece, building
      * out the Arrayofany instance it receives.
      *
      * @return A valid <arrayofany> element bound to an
      * Arrrayofany instance.
      */
     private Arrayofany buildArrayOfAny(Arrayofany arrayOfAny)
     {
         // Create a simple <stringelement> and move it into place
         // under <arrayofany>.
         StringelementDocument stringElementDoc =
             StringelementDocument.Factory.newInstance();
         stringElementDoc.setStringelement("some text");
         XmlCursor childCursor = stringElementDoc.newCursor();
         childCursor.toFirstContentToken();

         // Add a cursor to mark the position at which the new child
         // XML will be moved.
         XmlCursor arrayCursor = arrayOfAny.newCursor();
         arrayCursor.toNextToken();
         childCursor.moveXml(arrayCursor);
         childCursor.dispose();

         // Create a <someelement> that contains a <stringlist>
         // child element, then get the XmlObject representing the new
         // <stringlist>. Note that the XmlCursor.beginElement method
         // leaves the cursor between START and END tokens -- where
         // content can be placed.
         arrayCursor.beginElement("someelement", m_namespaceUri);
         arrayCursor.beginElement("stringlist", m_namespaceUri);
         arrayCursor.toPrevToken();
         XmlObject stringList = arrayCursor.getObject();

         // The cursor's no longer needed.
         arrayCursor.dispose();

         // Create the <stringlist> element's value and set it.
         ListOfStrings stringListValue = buildListOfStrings();
         if (stringListValue == null)
         {
             return null;
         }
         stringList.set(stringListValue);

         // Validate the new XML.
         if (!validateXml(arrayOfAny))
         {
             return null;
         }

         return arrayOfAny;
     }

     /**
      * Creates an instance of the ListOfStrings complex type defined
      * in the schema. The instance returned by this method can be
      * inserted using either a set* operation or a cursor, as in
      * {@link #buildArrayOfAny()}.
      *
      * @return A valid instance of ListOfStrings.
      */
     private ListOfStrings buildListOfStrings()
     {
         // Create an instance of the ListOfStrings complex type.
         ListOfStrings stringList = ListOfStrings.Factory.newInstance();
         stringList.setId("001");

         // Add two children for the instance's root.
         XmlString stringElement = stringList.addNewStringelement();
         stringElement.setStringValue("string1");
         stringElement = stringList.addNewStringelement();
         stringElement.setStringValue("string2");

         // Validate the new XML.
         if (!validateXml(stringList))
         {
             return null;
         }

         return stringList;
     }

     /**
      * <p>Validates the XML, printing error messages when the XML is invalid. Note
      * that this method will properly validate any instance of a compiled schema
      * type because all of these types extend XmlObject.</p>
      *
      * <p>Note that in actual practice, you'll probably want to use an assertion
      * when validating if you want to ensure that your code doesn't pass along
      * invalid XML. This sample prints the generated XML whether or not it's
      * valid so that you can see the result in both cases.</p>
      *
      * @param xml The XML to validate.
      * @return <code>true</code> if the XML is valid; otherwise, <code>false</code>
      */
     public static boolean validateXml(XmlObject xml)
     {
         boolean isXmlValid = false;

         // A collection instance to hold validation error messages.
         ArrayList validationMessages = new ArrayList();

         // Validate the XML, collecting messages.
         isXmlValid = xml.validate(
                 new XmlOptions().setErrorListener(validationMessages));

         // If the XML isn't valid, print the messages.
         if (!isXmlValid)
         {
             printErrors(validationMessages);
         }
         return isXmlValid;
     }

     /**
      * Receives the collection containing errors found during
      * validation and print the errors to the console.
      *
      * @param validationErrors The validation errors.
      */
     public static void printErrors(ArrayList validationErrors)
     {
         Iterator iter = validationErrors.iterator();
         while (iter.hasNext())
         {
             System.out.println(">> " + iter.next() + "\n");
         }
     }

     /**
      * <p>Creates a File from the XML path provided in main arguments, then
      * parses the file's contents into a type generated from schema.</p>
      * <p/>
      * <p>Note that this work might have been done in main. Isolating it here
      * makes the code separately available from outside this class.</p>
      *
      * @param xmlFilePath A path to XML based on the schema in inventory.xsd.
      * @return An instance of a generated schema type that contains the parsed
      *         XML.
      */
     public XmlObject parseXml(String xmlFilePath)
     {
         File xmlFile = new File(xmlFilePath);
         XmlObject xml = null;
         try
         {
             xml = XmlObject.Factory.parse(xmlFile);
         } catch (XmlException e)
         {
             e.printStackTrace();
         } catch (IOException e)
         {
             e.printStackTrace();
         }
         return xml;
     }
 }
	/* 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.
	*/

	package org.apache.xmlbeans.samples.anytype;

	import org.apache.xmlbeans.*;
	import org.apache.xmlbeans.samples.any.ListOfStrings;
	import org.apache.xmlbeans.samples.any.RootDocument;
	import org.apache.xmlbeans.samples.any.StringelementDocument;
	import org.apache.xmlbeans.samples.any.RootDocument.Root.Arrayofany;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Iterator;

	import javax.xml.namespace.QName;

	/**
	* A sample that illustrates various ways to manipulate XML whose
	* schema defines elements as type xs:any. Unlike its treatment of
	* other schema types, XMLBeans does not generate accessors for the
	* xs:any particle when compiling schema. Instead, your code
	* handles instances of this type through any of several alternative
	* means, including XPath queries, the selectChildren method,
	* XmlCursor instances and the DOM API. This samples illustrates
	* these alternative approaches.
	*/
	public class Any
	{
	private static final String m_namespaceUri = "http://xmlbeans.apache.org/samples/any";

	/**
	* Receives <root> XML instance, executing methods that
	* edit the received instance or create a new one.
	*
	* @param args An array in which the first item is a
	* path to the XML instance file.
	*/
	public static void main(String[] args)
	{
	Any thisSample = new Any();
	System.out.println("Running Any.buildDocFromScratch\n");
	thisSample.buildDocFromScratch();

	RootDocument rootDoc = (RootDocument)thisSample.parseXml(args[0]);

	System.out.println("Running Any.editExistingDocWithSelectChildren\n");
	thisSample.editExistingDocWithSelectChildren(rootDoc);

	System.out.println("Running Any.editExistingDocWithDOM\n");
	thisSample.editExistingDocWithDOM(rootDoc);

	System.out.println("Running Any.editExistingDocWithSelectPath\n");
	thisSample.editExistingDocWithSelectPath(rootDoc);
	}

	/**
	* Creates a new <root> document from scratch.
	*
	* This method illustrates how you can use XmlCursor instances
	* to build XML that is defined in schema as xs:any.
	*
	* @return <code>true</code> if the new document is valid;
	* otherwise, <code>false</code>.
	*/
	public boolean buildDocFromScratch()
	{
	// Start by creating a <root> element that will contain
	// the children built by this method.
	RootDocument rootDoc = RootDocument.Factory.newInstance();
	RootDocument.Root root = rootDoc.addNewRoot();

	// Add the first element, <stringelement>.
	root.setStringelement("some text");

	// Create an XmlObject in which to build the second
	// element in the sequence, <anyfoo>. Here, the
	// XmlObject instance is simply a kind of incubator
	// for the XML. Later the XML will be moved into the
	// document this code is building.
	XmlObject anyFoo = XmlObject.Factory.newInstance();

	// Add a cursor to do the work of building the XML.
	XmlCursor childCursor = anyFoo.newCursor();
	childCursor.toNextToken();

	// Add the element in the schema's namespace, then add
	// element content.
	childCursor.beginElement(new QName(m_namespaceUri, "anyfoo"));
	childCursor.insertChars("some text");

	// Move the cursor back to the new element's top, where
	// it can grab the element's XML.
	childCursor.toStartDoc();
	childCursor.toNextToken();

	// Move the XML into the <root> document by moving it
	// from a position at one cursor to a position at
	// another.
	XmlCursor rootCursor = root.newCursor();
	rootCursor.toEndToken();
	childCursor.moveXml(rootCursor);

	// Add the fourth element, <arrayofany>, by building it
	// elsewhere, then moving the new XML into place under
	// <root>.
	Arrayofany arrayOfAny = root.addNewArrayofany();
	if (buildArrayOfAny(arrayOfAny) == null)
	{
	return false;
	}

	childCursor.dispose();
	rootCursor.dispose();

	// Print and validate the result.
	System.out.println("Output: The <root> document built from scratch.\n");
	System.out.println(rootDoc + "\n");
	return validateXml(rootDoc);
	}

	/**
	* Replaces the <anyfoo> element with an <anybar> element in the
	* incoming XML.
	*
	* This method illustrates how you can use the XmlCursor.selectChildren
	* method to retrieve child elements whose type is defined as
	* xs:any in schema.
	*
	* @param rootDoc An instance of the <root> XML document.
	* @return <code>true</code> if the editing XML is valid;
	* otherwise, <code>false</code>.
	*/
	public boolean editExistingDocWithSelectChildren(RootDocument rootDoc)
	{
	RootDocument.Root root = rootDoc.getRoot();

	// Select the <anyfoo> children of <root>.
	XmlObject[] stringElements =
	root.selectChildren(new QName(m_namespaceUri, "anyfoo"));

	// If the element is there, replace it with another element.
	if (stringElements.length > 0)
	{
	XmlCursor editCursor = stringElements[0].newCursor();
	editCursor.removeXml();
	editCursor.beginElement(new QName(m_namespaceUri, "anybar"));
	editCursor.insertChars("some other text");
	editCursor.dispose();
	}
	System.out.println("Output: The <anyfoo> element has been replaced\n" +
	"by an <anybar> element.\n");
	System.out.println(rootDoc + "\n");
	return validateXml(rootDoc);
	}

	/**
	* Adds a new <bar> element between the first and second
	* children of the <arrayofany> element.
	*
	* This method illustrates how you can use DOM methods to
	* retrieve and edit elements whose type is defined as
	* xs:any in schema.
	*
	* @param rootDoc An instance of the <root> XML document.
	* @return <code>true</code> if the editing XML is valid;
	* otherwise, <code>false</code>.
	*/
	public boolean editExistingDocWithDOM(RootDocument rootDoc)
	{
	RootDocument.Root root = rootDoc.getRoot();

	// Get the DOM nodes for the <arrayofany> element's children.
	Node arrayOfAnyNode = root.getArrayofany().getDomNode();

	// You don't have get* accessors for any of the <arrayofany>
	// element's children, so use DOM to identify the first
	// and second elements while looping through the child list.
	NodeList childList = arrayOfAnyNode.getChildNodes();
	Element firstElementChild = null;
	Element secondElementChild = null;

	// Find the first child element and make sure it's
	// <stringelement>.
	for (int i = 0; i < childList.getLength(); i++)
	{
	Node node = childList.item(i);
	if (node.getNodeType() == Node.ELEMENT_NODE)
	{
	if (node.getLocalName().equals("stringelement"))
	{
	firstElementChild = (Element)node;
	break;
	}
	}
	}
	if (firstElementChild == null) {return false;}

	// Find the second child element and make sure it's
	// <someelement>.
	Node node = firstElementChild.getNextSibling();
	do {
	if (node.getNodeType() == Node.ELEMENT_NODE)
	{
	if (node.getLocalName().equals("someelement"))
	{
	secondElementChild = (Element)node;
	break;
	}
	}
	node = node.getNextSibling();
	} while (node != null);
	if (secondElementChild == null) {return false;}

	// Create and insert a new <bar> element.
	Element fooElement =
	secondElementChild.getOwnerDocument().createElementNS("http://openuri.org","bar");
	Node valueNode =
	fooElement.getOwnerDocument().createTextNode("some text");
	fooElement.appendChild(valueNode);
	arrayOfAnyNode.insertBefore(fooElement, secondElementChild);

	System.out.println("Output: <arrayofany> has a new <bar> child element.\n");
	System.out.println(rootDoc + "\n");
	return validateXml(rootDoc);
	}

	/**
	* Edits incoming <root> XML to make the following changes: replace
	* <somelement> with its <stringlist> child; add a new <foo>
	* element as the second child of <arrayofany>.
	*
	* This method illustrates how you can use the selectPath method
	* to find an element defined as xs:any in schema, then use
	* XmlCursor instances to edit the XML.
	*
	* @param rootDoc An instance of the <root> XML document.
	* @return <code>true</code> if the editing XML is valid;
	* otherwise, <code>false</code>.
	*/
	public boolean editExistingDocWithSelectPath(RootDocument rootDoc)
	{
	String namespaceDecl = "declare namespace any='" +
	m_namespaceUri + "'; ";
	XmlCursor selectionCursor = rootDoc.getRoot().getArrayofany().newCursor();

	// Save the cursor's position for later, then use XPath
	// and cursor movement to position the cursor at
	// the <stringlist> element.
	selectionCursor.push();
	selectionCursor.selectPath(namespaceDecl +
	"$this//any:someelement/any:stringlist");
	selectionCursor.toNextSelection();

	// Create a new cursor and move it to the selection
	// cursor's <someelement> parent. Moving the
	// <stringlist> element to this position, displacing
	// the <someelement> downward, then removing the
	// <someelement> XML effectively replaces <someelement>
	// with <stringlist>.
	XmlCursor editCursor = selectionCursor.newCursor();
	editCursor.toParent();
	selectionCursor.moveXml(editCursor);
	editCursor.removeXml();
	editCursor.dispose();

	// Return the cursor to the <arrayofany> element so you
	// can do more editing. Then move the cursor to the second
	// child and insert a new element as second child.
	selectionCursor.pop();
	selectionCursor.toFirstChild();
	selectionCursor.toNextSibling();
	selectionCursor.beginElement("foo", "http://openuri.org");
	selectionCursor.insertChars("some text");
	selectionCursor.dispose();

	System.out.println("Output: <stringlist> has been promoted to replace \n" +
	"<someelement>, and there's a new <foo> element.\n");
	System.out.println(rootDoc + "\n");
	return validateXml(rootDoc);
	}

	/**
	* Like the code in the buildDocFromScratch method, this code
	* uses the XmlCursor to build XML piece by piece, building
	* out the Arrayofany instance it receives.
	*
	* @return A valid <arrayofany> element bound to an
	* Arrrayofany instance.
	*/
	private Arrayofany buildArrayOfAny(Arrayofany arrayOfAny)
	{
	// Create a simple <stringelement> and move it into place
	// under <arrayofany>.
	StringelementDocument stringElementDoc =
	StringelementDocument.Factory.newInstance();
	stringElementDoc.setStringelement("some text");
	XmlCursor childCursor = stringElementDoc.newCursor();
	childCursor.toFirstContentToken();

	// Add a cursor to mark the position at which the new child
	// XML will be moved.
	XmlCursor arrayCursor = arrayOfAny.newCursor();
	arrayCursor.toNextToken();
	childCursor.moveXml(arrayCursor);
	childCursor.dispose();

	// Create a <someelement> that contains a <stringlist>
	// child element, then get the XmlObject representing the new
	// <stringlist>. Note that the XmlCursor.beginElement method
	// leaves the cursor between START and END tokens -- where
	// content can be placed.
	arrayCursor.beginElement("someelement", m_namespaceUri);
	arrayCursor.beginElement("stringlist", m_namespaceUri);
	arrayCursor.toPrevToken();
	XmlObject stringList = arrayCursor.getObject();

	// The cursor's no longer needed.
	arrayCursor.dispose();

	// Create the <stringlist> element's value and set it.
	ListOfStrings stringListValue = buildListOfStrings();
	if (stringListValue == null)
	{
	return null;
	}
	stringList.set(stringListValue);

	// Validate the new XML.
	if (!validateXml(arrayOfAny))
	{
	return null;
	}

	return arrayOfAny;
	}

	/**
	* Creates an instance of the ListOfStrings complex type defined
	* in the schema. The instance returned by this method can be
	* inserted using either a set* operation or a cursor, as in
	* {@link #buildArrayOfAny()}.
	*
	* @return A valid instance of ListOfStrings.
	*/
	private ListOfStrings buildListOfStrings()
	{
	// Create an instance of the ListOfStrings complex type.
	ListOfStrings stringList = ListOfStrings.Factory.newInstance();
	stringList.setId("001");

	// Add two children for the instance's root.
	XmlString stringElement = stringList.addNewStringelement();
	stringElement.setStringValue("string1");
	stringElement = stringList.addNewStringelement();
	stringElement.setStringValue("string2");

	// Validate the new XML.
	if (!validateXml(stringList))
	{
	return null;
	}

	return stringList;
	}

	/**
	* <p>Validates the XML, printing error messages when the XML is invalid. Note
	* that this method will properly validate any instance of a compiled schema
	* type because all of these types extend XmlObject.</p>
	*
	* <p>Note that in actual practice, you'll probably want to use an assertion
	* when validating if you want to ensure that your code doesn't pass along
	* invalid XML. This sample prints the generated XML whether or not it's
	* valid so that you can see the result in both cases.</p>
	*
	* @param xml The XML to validate.
	* @return <code>true</code> if the XML is valid; otherwise, <code>false</code>
	*/
	public static boolean validateXml(XmlObject xml)
	{
	boolean isXmlValid = false;

	// A collection instance to hold validation error messages.
	ArrayList validationMessages = new ArrayList();

	// Validate the XML, collecting messages.
	isXmlValid = xml.validate(
	new XmlOptions().setErrorListener(validationMessages));

	// If the XML isn't valid, print the messages.
	if (!isXmlValid)
	{
	printErrors(validationMessages);
	}
	return isXmlValid;
	}

	/**
	* Receives the collection containing errors found during
	* validation and print the errors to the console.
	*
	* @param validationErrors The validation errors.
	*/
	public static void printErrors(ArrayList validationErrors)
	{
	Iterator iter = validationErrors.iterator();
	while (iter.hasNext())
	{
	System.out.println(">> " + iter.next() + "\n");
	}
	}

	/**
	* <p>Creates a File from the XML path provided in main arguments, then
	* parses the file's contents into a type generated from schema.</p>
	* <p/>
	* <p>Note that this work might have been done in main. Isolating it here
	* makes the code separately available from outside this class.</p>
	*
	* @param xmlFilePath A path to XML based on the schema in inventory.xsd.
	* @return An instance of a generated schema type that contains the parsed
	* XML.
	*/
	public XmlObject parseXml(String xmlFilePath)
	{
	File xmlFile = new File(xmlFilePath);
	XmlObject xml = null;
	try
	{
	xml = XmlObject.Factory.parse(xmlFile);
	} catch (XmlException e)
	{
	e.printStackTrace();
	} catch (IOException e)
	{
	e.printStackTrace();
	}
	return xml;
	}
	}