/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.xml.bind;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.adapters.XmlAdapter;

import javax.xml.bind.attachment.AttachmentMarshaller;

import javax.xml.validation.Schema;

import java.io.File;

/**

 * <p>

 * of serializing Java content trees back into XML data.  It provides the basic

 * marshalling methods:

 *

 * <p>

 * <i>Assume the following setup code for all following code fragments:</i>

 * <blockquote>

 *    <pre>

 *       JAXBContext jc = JAXBContext.newInstance( "com.acme.foo" );

 *       Unmarshaller u = jc.createUnmarshaller();

 *       Object element = u.unmarshal( new File( "foo.xml" ) );

 *       Marshaller m = jc.createMarshaller();

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a File:

 * <blockquote>

 *    <pre>

 *       OutputStream os = new FileOutputStream( "nosferatu.xml" );

 *       m.marshal( element, os );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a SAX ContentHandler:

 * <blockquote>

 *    <pre>

 *       // assume MyContentHandler instanceof ContentHandler

 *       m.marshal( element, new MyContentHandler() );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a DOM Node:

 * <blockquote>

 *    <pre>

 *       DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

 *       dbf.setNamespaceAware(true);

 *       DocumentBuilder db = dbf.newDocumentBuilder();

 *       Document doc = db.newDocument();

 *

 *       m.marshal( element, doc );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a java.io.OutputStream:

 * <blockquote>

 *    <pre>

 *       m.marshal( element, System.out );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a java.io.Writer:

 * <blockquote>

 *    <pre>

 *       m.marshal( element, new PrintWriter( System.out ) );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a javax.xml.transform.SAXResult:

 * <blockquote>

 *    <pre>

 *       // assume MyContentHandler instanceof ContentHandler

 *       SAXResult result = new SAXResult( new MyContentHandler() );

 *

 *       m.marshal( element, result );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a javax.xml.transform.DOMResult:

 * <blockquote>

 *    <pre>

 *       DOMResult result = new DOMResult();

 *

 *       m.marshal( element, result );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a javax.xml.transform.StreamResult:

 * <blockquote>

 *    <pre>

 *       StreamResult result = new StreamResult( System.out );

 *

 *       m.marshal( element, result );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a javax.xml.stream.XMLStreamWriter:

 * <blockquote>

 *    <pre>

 *       XMLStreamWriter xmlStreamWriter =

 *           XMLOutputFactory.newInstance().createXMLStreamWriter( ... );

 *

 *       m.marshal( element, xmlStreamWriter );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * Marshalling to a javax.xml.stream.XMLEventWriter:

 * <blockquote>

 *    <pre>

 *       XMLEventWriter xmlEventWriter =

 *           XMLOutputFactory.newInstance().createXMLEventWriter( ... );

 *

 *       m.marshal( element, xmlEventWriter );

 *    </pre>

 * </blockquote>

 *

 * <p>

 * <a name="elementMarshalling"></a>

 * <b>Marshalling content tree rooted by a JAXB element</b><br>

 * <blockquote>

 * The first parameter of the overloaded

 * JAXB element as computed by

 * {@link JAXBIntrospector#isElement(java.lang.Object)};

 * {@link MarshalException}. There exist two mechanisms

 * to enable marshalling an instance that is not a JAXB element.

 * One method is to wrap the instance as a value of a {@link JAXBElement},

 * and pass the wrapper element as the first parameter to

 * is also possible to simply annotate the instance's class with

 * @{@link XmlRootElement}.

 * </blockquote>

 *

 * <p>

 * <b>Encoding</b><br>

 * <blockquote>

 * By default, the Marshaller will use UTF-8 encoding when generating XML data

 * {@link #setProperty(String,Object) setProperty} API to change the output

 * encoding used during these marshal operations.  Client applications are

 * expected to supply a valid character encoding name as defined in the

 * <a href="http://www.w3.org/TR/2000/REC-xml-20001006#charencoding">W3C XML 1.0

 * Recommendation</a> and supported by your Java Platform.

 * </blockquote>

 *

 * <p>

 * <b>Validation and Well-Formedness</b><br>

 * <blockquote>

 * <p>

 * Client applications are not required to validate the Java content tree prior

 * to calling any of the marshal API's.  Furthermore, there is no requirement

 * that the Java content tree be valid with respect to its original schema in

 * order to marshal it back into XML data.  Different JAXB Providers will

 * support marshalling invalid Java content trees at varying levels, however

 * all JAXB Providers must be able to marshal a valid content tree back to

 * is unable to complete the marshal operation due to invalid content.  Some

 * JAXB Providers will fully allow marshalling invalid content, others will fail

 * on the first validation error.

 * <p>

 * Even when schema validation is not explictly enabled for the marshal operation,

 * it is possible that certain types of validation events will be detected

 * during the operation.  Validation events will be reported to the registered

 * event handler.  If the client application has not registered an event handler

 * prior to invoking one of the marshal API's, then events will be delivered to

 * a default event handler which will terminate the marshal operation after

 * encountering the first error or fatal error. Note that for JAXB 2.0 and

 * later versions, {@link javax.xml.bind.helpers.DefaultValidationEventHandler} is

 * no longer used.

 *

 * </blockquote>

 *

 * <p>

 * <a name="supportedProps"></a>

 * <b>Supported Properties</b><br>

 * <blockquote>

 * <p>

 * All JAXB Providers are required to support the following set of properties.

 * Some providers may support additional properties.

 * <dl>

 *   <dd>The output encoding to use when marshalling the XML data.  The

 *               Marshaller will use "UTF-8" by default if this property is not

 *       specified.</dd>

 *   <dd>This property controls whether or not the Marshaller will format

 *       the resulting XML data with line breaks and indentation.  A

 *       true value for this property indicates human readable indented

 *       xml data, while a false value indicates unformatted xml data.

 *       The Marshaller will default to false (unformatted) if this

 *       property is not specified.</dd>

 *   <dd>This property allows the client application to specify an

 *       xsi:schemaLocation attribute in the generated XML data.  The format of

 *       the schemaLocation attribute value is discussed in an easy to

 *       understand, non-normative form in

 *       <a href="http://www.w3.org/TR/xmlschema-0/#schemaLocation">Section 5.6

 *       of the W3C XML Schema Part 0: Primer</a> and specified in

 *       <a href="http://www.w3.org/TR/xmlschema-1/#Instance_Document_Constructions">

 *       Section 2.6 of the W3C XML Schema Part 1: Structures</a>.</dd>

 *   <dd>This property allows the client application to specify an

 *       xsi:noNamespaceSchemaLocation attribute in the generated XML

 *       data.  The format of the schemaLocation attribute value is discussed in

 *       an easy to understand, non-normative form in

 *       <a href="http://www.w3.org/TR/xmlschema-0/#schemaLocation">Section 5.6

 *       of the W3C XML Schema Part 0: Primer</a> and specified in

 *       <a href="http://www.w3.org/TR/xmlschema-1/#Instance_Document_Constructions">

 *       Section 2.6 of the W3C XML Schema Part 1: Structures</a>.</dd>

 *   <dd>This property determines whether or not document level events will be

 *       generated by the Marshaller.  If the property is not specified, the

 *       on which marshal api you are using - when this property is set to true:<br>

 *       <ul>

 *         <li>{@link #marshal(Object,org.xml.sax.ContentHandler) marshal(Object,ContentHandler)} - the Marshaller won't

 *             invoke {@link org.xml.sax.ContentHandler#startDocument()} and

 *             {@link org.xml.sax.ContentHandler#endDocument()}.</li>

 *         <li>{@link #marshal(Object,org.w3c.dom.Node) marshal(Object,Node)} - the property has no effect on this

 *             API.</li>

 *         <li>{@link #marshal(Object,java.io.OutputStream) marshal(Object,OutputStream)} - the Marshaller won't

 *             generate an xml declaration.</li>

 *         <li>{@link #marshal(Object,java.io.Writer) marshal(Object,Writer)} - the Marshaller won't

 *             generate an xml declaration.</li>

 *         <li>{@link #marshal(Object,javax.xml.transform.Result) marshal(Object,Result)} - depends on the kind of

 *             Result object, see semantics for Node, ContentHandler, and Stream APIs</li>

 *         <li>{@link #marshal(Object,javax.xml.stream.XMLEventWriter) marshal(Object,XMLEventWriter)} - the

 *             Marshaller will not generate {@link javax.xml.stream.events.XMLEvent#START_DOCUMENT} and

 *             {@link javax.xml.stream.events.XMLEvent#END_DOCUMENT} events.</li>

 *         <li>{@link #marshal(Object,javax.xml.stream.XMLStreamWriter) marshal(Object,XMLStreamWriter)} - the

 *             Marshaller will not generate {@link javax.xml.stream.events.XMLEvent#START_DOCUMENT} and

 *             {@link javax.xml.stream.events.XMLEvent#END_DOCUMENT} events.</li>

 *       </ul>

 *   </dd>

 * </dl>

 * </blockquote>

 *

 * <p>

 * <a name="marshalEventCallback"></a>

 * <b>Marshal Event Callbacks</b><br>

 * <blockquote>

 * "The {@link Marshaller} provides two styles of callback mechanisms

 * that allow application specific processing during key points in the

 * unmarshalling process.  In 'class defined' event callbacks, application

 * specific code placed in JAXB mapped classes is triggered during

 * marshalling.  'External listeners' allow for centralized processing

 * of marshal events in one callback method rather than by type event callbacks.

 *

 * <p>

 * Class defined event callback methods allow any JAXB mapped class to specify

 * its own specific callback methods by defining methods with the following method signatures:

 * <blockquote>

 * <pre>

 *   // Invoked by Marshaller after it has created an instance of this object.

 *   boolean beforeMarshal(Marshaller);

 *

 *   // Invoked by Marshaller after it has marshalled all properties of this object.

 *   void afterMarshal(Marshaller);

 * </pre>

 * </blockquote>

 * The class defined event callback methods should be used when the callback method requires

 * 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 a {@link Marshaller#setListener(Listener)}. The external listener receives all callback events,

 * allowing for more centralized processing than per class defined callback methods.

 * <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#beforeMarshal(Object)} and {@link Listener#afterMarshal(Object)}.

 * <p>

 * An event callback method throwing an exception terminates the current marshal process.

 * </blockquote>

 *

 * @author <ul><li>Kohsuke Kawaguchi, Sun Microsystems, Inc.</li><li>Ryan Shoemaker, Sun Microsystems, Inc.</li><li>Joe Fialli, Sun Microsystems, Inc.</li></ul>

 * @see JAXBContext

 * @see Validator

 * @see Unmarshaller

 * @since 1.6, JAXB 1.0

 */

public interface Marshaller {

    /**

     * The name of the property used to specify the output encoding in

     * the marshalled XML data.

     */

    public static final String JAXB_ENCODING =

        "jaxb.encoding";

    /**

     * The name of the property used to specify whether or not the marshalled

     * XML data is formatted with linefeeds and indentation.

     */

    public static final String JAXB_FORMATTED_OUTPUT =

        "jaxb.formatted.output";

    /**

     * The name of the property used to specify the xsi:schemaLocation

     * attribute value to place in the marshalled XML output.

     */

    public static final String JAXB_SCHEMA_LOCATION =

        "jaxb.schemaLocation";

    /**

     * The name of the property used to specify the

     * xsi:noNamespaceSchemaLocation attribute value to place in the marshalled

     * XML output.

     */

    public static final String JAXB_NO_NAMESPACE_SCHEMA_LOCATION =

        "jaxb.noNamespaceSchemaLocation";

    /**

     * The name of the property used to specify whether or not the marshaller

     * will generate document level events (ie calling startDocument or endDocument).

     */

    public static final String JAXB_FRAGMENT =

        "jaxb.fragment";

    /**

     *

     * <p>

     * All JAXB Providers must at least support

     * {@link javax.xml.transform.dom.DOMResult},

     * {@link javax.xml.transform.sax.SAXResult}, and

     * {@link javax.xml.transform.stream.StreamResult}. It can

     *

     * @param jaxbElement

     *      The root of content tree to be marshalled.

     * @param result

     *      XML will be sent to this Result

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     */

    public void marshal( Object jaxbElement, javax.xml.transform.Result result )

        throws JAXBException;

    /**

     *

     * @param jaxbElement

     *      The root of content tree to be marshalled.

     * @param os

     *      XML will be added to this stream.

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     */

    public void marshal( Object jaxbElement, java.io.OutputStream os )

        throws JAXBException;

    /**

     *

     * @param jaxbElement

     *      The root of content tree to be marshalled.

     * @param output

     *      File to be written. If this file already exists, it will be overwritten.

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     * @since 1.6, JAXB 2.1

     */

    public void marshal( Object jaxbElement, File output )

        throws JAXBException;

    /**

     *

     * @param jaxbElement

     *      The root of content tree to be marshalled.

     * @param writer

     *      XML will be sent to this writer.

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     */

    public void marshal( Object jaxbElement, java.io.Writer writer )

        throws JAXBException;

    /**

     *

     * @param jaxbElement

     *      The root of content tree to be marshalled.

     * @param handler

     *      XML will be sent to this handler as SAX2 events.

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     */

    public void marshal( Object jaxbElement, org.xml.sax.ContentHandler handler )

        throws JAXBException;

    /**

     *

     * @param jaxbElement

     *      The content tree to be marshalled.

     * @param node

     *      DOM nodes will be added as children of this node.

     *      This parameter must be a Node that accepts children

     *      ({@link org.w3c.dom.Document},

     *      {@link  org.w3c.dom.DocumentFragment}, or

     *      {@link  org.w3c.dom.Element})

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     */

    public void marshal( Object jaxbElement, org.w3c.dom.Node node )

        throws JAXBException;

    /**

     * {@link javax.xml.stream.XMLStreamWriter}.

     *

     * @param jaxbElement

     *      The content tree to be marshalled.

     * @param writer

     *      XML will be sent to this writer.

     *

     * @throws JAXBException

     *      If any unexpected problem occurs during the marshalling.

     * @throws MarshalException

     *      If the {@link ValidationEventHandler ValidationEventHandler}

     *      Marshalling a JAXB element</a>.

     * @throws IllegalArgumentException

     *      If any of the method parameters are null

     * @since 1.6, JAXB 2.0

     */

    public void marshal( Object jaxbElement, javax.xml.stream.XMLStreamWriter writer )

        throws JAXBException;