jdk-sandbox: comparison jaxws/src/java.xml.bind/share/classes/javax/xml/bind/Unmarshaller.java

equal deleted inserted replaced

-:1550b2f6b63d
+:88470f768658
 /*
-* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * Additionally, when the root element of XML data has an <tt>xsi:type</tt> attribute and
 * that attribute's value references a type definition that is mapped
 * to a JAXB mapped class by {@link JAXBContext}, that the root
 * element's <tt>xsi:type</tt> attribute takes
 * precedence over the unmarshal methods <tt>declaredType</tt> parameter.
-* These methods always return a <tt>JAXBElement&lt;declaredType></tt>
+* These methods always return a <tt>JAXBElement&lt;declaredType&gt;</tt>
 * instance. The table below shows how the properties of the returned JAXBElement
 * instance are set.
 *
 * <a name="unmarshalDeclaredTypeReturn"></a>
-* <p>
+*   <table summary="" border="2" rules="all" cellpadding="4">
-*   <table border="2" rules="all" cellpadding="4">
 *   <thead>
 *     <tr>
 *       <th align="center" colspan="2">
 *       Unmarshal By Declared Type returned JAXBElement
 *       </tr>
 * <p>
 * Unmarshal by declaredType from a <tt>org.w3c.dom.Node</tt>:
 * <blockquote>
 *    <pre>
 *       Schema fragment for example
-*       &lt;xs:schema>
+*       &lt;xs:schema&gt;
-*          &lt;xs:complexType name="FooType">...&lt;\xs:complexType>
+*          &lt;xs:complexType name="FooType"&gt;...&lt;\xs:complexType&gt;
-*          &lt;!-- global element declaration "PurchaseOrder" -->
+*          &lt;!-- global element declaration "PurchaseOrder" --&gt;
-*          &lt;xs:element name="PurchaseOrder">
+*          &lt;xs:element name="PurchaseOrder"&gt;
-*              &lt;xs:complexType>
+*              &lt;xs:complexType&gt;
-*                 &lt;xs:sequence>
+*                 &lt;xs:sequence&gt;
-*                    &lt;!-- local element declaration "foo" -->
+*                    &lt;!-- local element declaration "foo" --&gt;
-*                    &lt;xs:element name="foo" type="FooType"/>
+*                    &lt;xs:element name="foo" type="FooType"/&gt;
 *                    ...
-*                 &lt;/xs:sequence>
+*                 &lt;/xs:sequence&gt;
-*              &lt;/xs:complexType>
+*              &lt;/xs:complexType&gt;
-*          &lt;/xs:element>
+*          &lt;/xs:element&gt;
-*       &lt;/xs:schema>
+*       &lt;/xs:schema&gt;
 *
 *       JAXBContext jc = JAXBContext.newInstance( "com.acme.foo" );
 *       Unmarshaller u = jc.createUnmarshaller();
 *
 *       DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 *       Document doc = db.parse(new File( "nosferatu.xml"));
 *       Element  fooSubtree = ...; // traverse DOM till reach xml element foo, constrained by a
 *                                  // local element declaration in schema.
 *
 *       // FooType is the JAXB mapping of the type of local element declaration foo.
-*       JAXBElement&lt;FooType> foo = u.unmarshal( fooSubtree, FooType.class);
+*       JAXBElement&lt;FooType&gt; foo = u.unmarshal( fooSubtree, FooType.class);
 *    </pre>
 * </blockquote>
 *
 * <p>
 * <b>Support for SAX2.0 Compliant Parsers</b><br>
 * access to non-public methods and/or fields of the class.
 * <p>
 * The external listener callback mechanism enables the registration of a {@link Listener}
 * instance with an {@link Unmarshaller#setListener(Listener)}. The external listener receives all callback events,
 * allowing for more centralized processing than per class defined callback methods.  The external listener
-* receives events when unmarshalling proces is marshalling to a JAXB element or to JAXB mapped class.
+* receives events when unmarshalling process is marshalling to a JAXB element or to JAXB mapped class.
 * <p>
 * The 'class defined' and external listener event callback methods are independent of each other,
 * both can be called for one event.  The invocation ordering when both listener callback methods exist is
 * defined in {@link Listener#beforeUnmarshal(Object, Object)} and {@link Listener#afterUnmarshal(Object, Object)}.
 * <p>
 /**
 * Associates a configured instance of {@link XmlAdapter} with this unmarshaller.
 *
 * <p>
 * Every unmarshaller internally maintains a
-* {@link java.util.Map}&lt;{@link Class},{@link XmlAdapter}>,
+* {@link java.util.Map}&lt;{@link Class},{@link XmlAdapter}&gt;,
 * which it uses for unmarshalling classes whose fields/methods are annotated
 * with {@link javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter}.
 *
 * <p>
 * This method allows applications to use a configured instance of {@link XmlAdapter}.
 public <A extends XmlAdapter> A getAdapter( Class<A> type );
 /**
 * <p>Associate a context that resolves cid's, content-id URIs, to
 * binary data passed as attachments.</p>
-* <p/>
 * <p>Unmarshal time validation, enabled via {@link #setSchema(Schema)},
 * must be supported even when unmarshaller is performing XOP processing.
 * </p>
 *
 * @throws IllegalStateException if attempt to concurrently call this
 void setAttachmentUnmarshaller(AttachmentUnmarshaller au);
 AttachmentUnmarshaller getAttachmentUnmarshaller();
 /**
-* <p/>
+* <p>
 * Register an instance of an implementation of this class with {@link Unmarshaller} to externally listen
 * for unmarshal events.
-* <p/>
+* </p>
-* <p/>
+* <p>
 * This class enables pre and post processing of an instance of a JAXB mapped class
 * as XML data is unmarshalled into it. The event callbacks are called when unmarshalling
 * XML content into a JAXBElement instance or a JAXB mapped class that represents a complex type definition.
 * The event callbacks are not called when unmarshalling to an instance of a
 * Java datatype that represents a simple type definition.
-* <p/>
+* </p>
-* <p/>
+* <p>
 * External listener is one of two different mechanisms for defining unmarshal event callbacks.
 * See <a href="Unmarshaller.html#unmarshalEventCallback">Unmarshal Event Callbacks</a> for an overview.
-* <p/>
+* </p>
 * (@link #setListener(Listener)}
 * (@link #getListener()}
 *
 * @since 1.6, JAXB 2.0
 */
 public static abstract class Listener {
 /**
-* <p/>
+* <p>
 * Callback method invoked before unmarshalling into <tt>target</tt>.
-* <p/>
+* </p>
-* <p/>
+* <p>
 * This method is invoked immediately after <tt>target</tt> was created and
 * before the unmarshalling of this object begins. Note that
 * if the class of <tt>target</tt> defines its own <tt>beforeUnmarshal</tt> method,
 * the class specific callback method is invoked before this method is invoked.
 *
 */
 public void beforeUnmarshal(Object target, Object parent) {
 }
 /**
-* <p/>
+* <p>
 * Callback method invoked after unmarshalling XML data into <tt>target</tt>.
-* <p/>
+* </p>
-* <p/>
+* <p>
 * This method is invoked after all the properties (except IDREF) are unmarshalled into <tt>target</tt>,
 * but before <tt>target</tt> is set into its <tt>parent</tt> object.
 * Note that if the class of <tt>target</tt> defines its own <tt>afterUnmarshal</tt> method,
 * the class specific callback method is invoked before this method is invoked.
 *

changeset 28887	88470f768658
parent 25871	b80b84e87032
child 29839	6d5d546e953b