https://openjdk.java.net/ 
/*
 * Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 com.sun.org.apache.xml.internal.serializer;

import com.sun.org.apache.xml.internal.serializer.utils.MsgKey;
import com.sun.org.apache.xml.internal.serializer.utils.Utils;
import java.io.IOException;
import java.util.HashMap;
import java.util.Set;
import java.util.ArrayList;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.SourceLocator;
import javax.xml.transform.Transformer;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.ext.Locator2;


This class acts as a base class for the XML "serializers"
and the stream serializers.
It contains a number of common fields and methods.

@xsl.usageinternal
/**
 * This class acts as a base class for the XML "serializers"
 * and the stream serializers.
 * It contains a number of common fields and methods.
 *
 * @xsl.usage internal
 */
public abstract class SerializerBase
    implements SerializationHandler, SerializerConstants
{

    
To fire off the end element trace event

Params:
  • name – Name of element
/**
     * To fire off the end element trace event
     * @param name Name of element
     */
    protected void fireEndElem(String name)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null) {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENDELEMENT,name, (Attributes)null);
        }
    }

    
Report the characters trace event

Params:
  • chars –  content of characters
  • start –  starting index of characters to output
  • length –  number of characters to output
/**
     * Report the characters trace event
     * @param chars  content of characters
     * @param start  starting index of characters to output
     * @param length  number of characters to output
     */
    protected void fireCharEvent(char[] chars, int start, int length)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null) {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CHARACTERS, chars, start,length);
        }
    }

    
true if we still need to call startDocumentInternal()

/**
     * true if we still need to call startDocumentInternal()
     */
    protected boolean m_needToCallStartDocument = true;

    
True if a trailing "]]>" still needs to be written to be
written out. Used to merge adjacent CDATA sections

/** True if a trailing "]]>" still needs to be written to be
     * written out. Used to merge adjacent CDATA sections
     */
    protected boolean m_cdataTagOpen = false;

    
All the attributes of the current element, collected from
startPrefixMapping() calls, or addAddtribute() calls, or
from the SAX attributes in a startElement() call.

/**
     * All the attributes of the current element, collected from
     * startPrefixMapping() calls, or addAddtribute() calls, or
     * from the SAX attributes in a startElement() call.
     */
    protected AttributesImplSerializer m_attributes = new AttributesImplSerializer();

    
Tells if we're in an EntityRef event, true if it's greater than 0. Use
integer type to handle nested entity reference, increase m_inEntityRef in
startEntity, decrease m_inEntityRef in endEntity.

/**
     * Tells if we're in an EntityRef event, true if it's greater than 0. Use
     * integer type to handle nested entity reference, increase m_inEntityRef in
     * startEntity, decrease m_inEntityRef in endEntity.
     */
    protected int m_inEntityRef = 0;

    
This flag is set while receiving events from the external DTD 
/** This flag is set while receiving events from the external DTD */
    protected boolean m_inExternalDTD = false;

    
The System ID for the doc type.

/**
     * The System ID for the doc type.
     */
    protected String m_doctypeSystem;

    
The public ID for the doc type.

/**
     * The public ID for the doc type.
     */
    protected String m_doctypePublic;

    
Flag to tell that we need to add the doctype decl, which we can't do
until the first element is encountered.

/**
     * Flag to tell that we need to add the doctype decl, which we can't do
     * until the first element is encountered.
     */
    boolean m_needToOutputDocTypeDecl = true;

    
Tells if we should write the XML declaration.

/**
     * Tells if we should write the XML declaration.
     */
    protected boolean m_shouldNotWriteXMLHeader = false;

    
The standalone value for the doctype.

/**
     * The standalone value for the doctype.
     */
    private String m_standalone;

    
True if standalone was specified.

/**
     * True if standalone was specified.
     */
    protected boolean m_standaloneWasSpecified = false;

    
Determine if the output is a standalone.

/**
     * Determine if the output is a standalone.
     */
    protected boolean m_isStandalone = false;

    
Flag to tell if indenting (pretty-printing) is on.

/**
     * Flag to tell if indenting (pretty-printing) is on.
     */
    protected boolean m_doIndent = false;

    
Amount to indent.

/**
     * Amount to indent.
     */
    protected int m_indentAmount = 4;

    
Tells the XML version, for writing out to the XML decl.

/**
     * Tells the XML version, for writing out to the XML decl.
     */
    protected String m_version = null;

    
The mediatype.  Not used right now.

/**
     * The mediatype.  Not used right now.
     */
    protected String m_mediatype;

    
The transformer that was around when this output handler was created (if
any).

/**
     * The transformer that was around when this output handler was created (if
     * any).
     */
    private Transformer m_transformer;

    
Namespace support, that keeps track of currently defined
prefix/uri mappings. As processed elements come and go, so do
the associated mappings for that element.

/**
     * Namespace support, that keeps track of currently defined
     * prefix/uri mappings. As processed elements come and go, so do
     * the associated mappings for that element.
     */
    protected NamespaceMappings m_prefixMap;

    
Handle for firing generate events.  This interface may be implemented
by the referenced transformer object.

/**
     * Handle for firing generate events.  This interface may be implemented
     * by the referenced transformer object.
     */
    protected SerializerTrace m_tracer;

    protected SourceLocator m_sourceLocator;

    
The writer to send output to. This field is only used in the ToStream
serializers, but exists here just so that the fireStartDoc() and
other fire... methods can flush this writer when tracing.

/**
     * The writer to send output to. This field is only used in the ToStream
     * serializers, but exists here just so that the fireStartDoc() and
     * other fire... methods can flush this writer when tracing.
     */
    protected java.io.Writer m_writer = null;

    
A reference to "stack frame" corresponding to
the current element. Such a frame is pushed at a startElement()
and popped at an endElement(). This frame contains information about
the element, such as its namespace URI.

/**
     * A reference to "stack frame" corresponding to
     * the current element. Such a frame is pushed at a startElement()
     * and popped at an endElement(). This frame contains information about
     * the element, such as its namespace URI.
     */
    protected ElemContext m_elemContext = new ElemContext();

    
A utility buffer for converting Strings passed to
character() methods to character arrays.
Reusing this buffer means not creating a new character array
everytime and it runs faster.

/**
     * A utility buffer for converting Strings passed to
     * character() methods to character arrays.
     * Reusing this buffer means not creating a new character array
     * everytime and it runs faster.
     */
    protected char[] m_charsBuff = new char[60];

    
A utility buffer for converting Strings passed to
attribute methods to character arrays.
Reusing this buffer means not creating a new character array
everytime and it runs faster.

/**
     * A utility buffer for converting Strings passed to
     * attribute methods to character arrays.
     * Reusing this buffer means not creating a new character array
     * everytime and it runs faster.
     */
    protected char[] m_attrBuff = new char[30];

    private Locator m_locator = null;

    protected boolean m_needToCallSetDocumentInfo = true;

    
Receive notification of a comment.

See Also:
  • comment.comment(String)
/**
     * Receive notification of a comment.
     *
     * @see ExtendedLexicalHandler#comment(String)
     */
    public void comment(String data) throws SAXException {
        final int length = data.length();
        if (length > m_charsBuff.length) {
            m_charsBuff = new char[length * 2 + 1];
        }
        data.getChars(0, length, m_charsBuff, 0);
        comment(m_charsBuff, 0, length);
    }

    
If at runtime, when the qname of the attribute is
known, another prefix is specified for the attribute, then we can
patch or hack the name with this method. For
a qname of the form "ns?:otherprefix:name", this function patches the
qname by simply ignoring "otherprefix".
TODO: This method is a HACK! We do not have access to the
XML file, it sometimes generates a NS prefix of the form "ns?" for
an attribute.

/**
     * If at runtime, when the qname of the attribute is
     * known, another prefix is specified for the attribute, then we can
     * patch or hack the name with this method. For
     * a qname of the form "ns?:otherprefix:name", this function patches the
     * qname by simply ignoring "otherprefix".
     * TODO: This method is a HACK! We do not have access to the
     * XML file, it sometimes generates a NS prefix of the form "ns?" for
     * an attribute.
     */
    protected String patchName(String qname) {
        final int lastColon = qname.lastIndexOf(':');

        if (lastColon > 0) {
            final int firstColon = qname.indexOf(':');
            final String prefix = qname.substring(0, firstColon);
            final String localName = qname.substring(lastColon + 1);

            // If uri is "" then ignore prefix
            final String uri = m_prefixMap.lookupNamespace(prefix);
            if (uri != null && uri.length() == 0) {
                return localName;
            } else if (firstColon != lastColon) {
                return prefix + ':' + localName;
            }
        }
        return qname;
    }

    
Returns the local name of a qualified name. If the name has no prefix,
then it works as the identity (SAX2).

Params:
  • qname – the qualified name
Returns:the name, but excluding any prefix and colon.
/**
     * Returns the local name of a qualified name. If the name has no prefix,
     * then it works as the identity (SAX2).
     * @param qname the qualified name
     * @return the name, but excluding any prefix and colon.
     */
    protected static String getLocalName(String qname) {
        final int col = qname.lastIndexOf(':');
        return (col > 0) ? qname.substring(col + 1) : qname;
    }

    
Receive an object for locating the origin of SAX document events.

Params:
  • locator – An object that can return the location of any SAX document
event.
Receive an object for locating the origin of SAX document events.

    SAX parsers are strongly encouraged (though not absolutely
required) to supply a locator: if it does so, it must supply
the locator to the application by invoking this method before
invoking any of the other methods in the DocumentHandler
interface.
    

    The locator allows the application to determine the end
position of any document-related event, even if the parser is
not reporting an error.  Typically, the application will
use this information for reporting its own errors (such as
character content that does not match an application's
business rules).  The information returned by the locator
is probably not sufficient for use with a search engine.
    

    Note that the locator will return correct information only
during the invocation of the events in this interface.  The
application should not attempt to use it at any other time.
/**
     * Receive an object for locating the origin of SAX document events.
     *
     * @param locator An object that can return the location of any SAX document
     * event.
     *
     * Receive an object for locating the origin of SAX document events.
     *
     * <p>SAX parsers are strongly encouraged (though not absolutely
     * required) to supply a locator: if it does so, it must supply
     * the locator to the application by invoking this method before
     * invoking any of the other methods in the DocumentHandler
     * interface.</p>
     *
     * <p>The locator allows the application to determine the end
     * position of any document-related event, even if the parser is
     * not reporting an error.  Typically, the application will
     * use this information for reporting its own errors (such as
     * character content that does not match an application's
     * business rules).  The information returned by the locator
     * is probably not sufficient for use with a search engine.</p>
     *
     * <p>Note that the locator will return correct information only
     * during the invocation of the events in this interface.  The
     * application should not attempt to use it at any other time.</p>
     */
    public void setDocumentLocator(Locator locator) {
        m_locator = locator;
    }

    
Adds the given attribute to the set of collected attributes , but only if
there is a currently open element.
An element is currently open if a startElement() notification has
occured but the start of the element has not yet been written to the
output.  In the stream case this means that we have not yet been forced
to close the elements opening tag by another notification, such as a
character notification.

Params:
  • uri – the URI of the attribute
  • localName – the local name of the attribute
  • rawName –    the qualified name of the attribute
  • type – the type of the attribute (probably CDATA)
  • value – the value of the attribute
  • XSLAttribute – true if this attribute is coming from an xsl:attriute element
See Also:
/**
     * Adds the given attribute to the set of collected attributes , but only if
     * there is a currently open element.
     *
     * An element is currently open if a startElement() notification has
     * occured but the start of the element has not yet been written to the
     * output.  In the stream case this means that we have not yet been forced
     * to close the elements opening tag by another notification, such as a
     * character notification.
     *
     * @param uri the URI of the attribute
     * @param localName the local name of the attribute
     * @param rawName    the qualified name of the attribute
     * @param type the type of the attribute (probably CDATA)
     * @param value the value of the attribute
     * @param XSLAttribute true if this attribute is coming from an xsl:attriute element
     * @see ExtendedContentHandler#addAttribute(String, String, String, String, String)
     */
    public void addAttribute(String uri, String localName, String rawName,
                             String type, String value, boolean XSLAttribute)
        throws SAXException
    {
        if (m_elemContext.m_startTagOpen) {
            addAttributeAlways(uri, localName, rawName, type, value, XSLAttribute);
        }
    }

    
Adds the given attribute to the set of attributes, even if there is
no currently open element. This is useful if a SAX startPrefixMapping()
should need to add an attribute before the element name is seen.

Params:
  • uri – the URI of the attribute
  • localName – the local name of the attribute
  • rawName –   the qualified name of the attribute
  • type – the type of the attribute (probably CDATA)
  • value – the value of the attribute
  • XSLAttribute – true if this attribute is coming from an xsl:attribute element
Returns:true if the attribute was added,
false if an existing value was replaced.
/**
     * Adds the given attribute to the set of attributes, even if there is
     * no currently open element. This is useful if a SAX startPrefixMapping()
     * should need to add an attribute before the element name is seen.
     *
     * @param uri the URI of the attribute
     * @param localName the local name of the attribute
     * @param rawName   the qualified name of the attribute
     * @param type the type of the attribute (probably CDATA)
     * @param value the value of the attribute
     * @param XSLAttribute true if this attribute is coming from an xsl:attribute element
     * @return true if the attribute was added,
     * false if an existing value was replaced.
     */
    public boolean addAttributeAlways(String uri, String localName, String rawName,
                                      String type, String value, boolean XSLAttribute)
    {
        boolean was_added;
        int index;

        if (localName == null || uri == null || uri.length() == 0)
            index = m_attributes.getIndex(rawName);
        else {
            index = m_attributes.getIndex(uri,localName);
        }
        if (index >= 0) {
            /* We've seen the attribute before.
             * We may have a null uri or localName, but all
             * we really want to re-set is the value anyway.
             */
            m_attributes.setValue(index,value);
            was_added = false;
        } else {
            // the attribute doesn't exist yet, create it
            m_attributes.addAttribute(uri, localName, rawName, type, value);
            was_added = true;
        }
        return was_added;
    }

    
 Adds  the given attribute to the set of collected attributes,
but only if there is a currently open element.

Params:
  • name – the attribute's qualified name
  • value – the value of the attribute
/**
     *  Adds  the given attribute to the set of collected attributes,
     * but only if there is a currently open element.
     *
     * @param name the attribute's qualified name
     * @param value the value of the attribute
     */
    public void addAttribute(String name, final String value) {
        if (m_elemContext.m_startTagOpen) {
            final String patchedName = patchName(name);
            final String localName = getLocalName(patchedName);
            final String uri = getNamespaceURI(patchedName, false);

            addAttributeAlways(uri,localName, patchedName, "CDATA", value, false);
        }
    }

    
Adds the given xsl:attribute to the set of collected attributes,
but only if there is a currently open element.

Params:
  • name – the attribute's qualified name (prefix:localName)
  • value – the value of the attribute
  • uri – the URI that the prefix of the name points to
/**
     * Adds the given xsl:attribute to the set of collected attributes,
     * but only if there is a currently open element.
     *
     * @param name the attribute's qualified name (prefix:localName)
     * @param value the value of the attribute
     * @param uri the URI that the prefix of the name points to
     */
    public void addXSLAttribute(String name, final String value, final String uri) {
        if (m_elemContext.m_startTagOpen) {
            final String patchedName = patchName(name);
            final String localName = getLocalName(patchedName);

            addAttributeAlways(uri,localName, patchedName, "CDATA", value, true);
        }
    }

    
Add the given attributes to the currently collected ones. These
attributes are always added, regardless of whether on not an element
is currently open.

Params:
  • atts – List of attributes to add to this list
/**
     * Add the given attributes to the currently collected ones. These
     * attributes are always added, regardless of whether on not an element
     * is currently open.
     * @param atts List of attributes to add to this list
     */
    public void addAttributes(Attributes atts) throws SAXException {
        int nAtts = atts.getLength();
        for (int i = 0; i < nAtts; i++) {
            String uri = atts.getURI(i);

            if (null == uri)
                uri = "";

            addAttributeAlways(
                uri,
                atts.getLocalName(i),
                atts.getQName(i),
                atts.getType(i),
                atts.getValue(i),
                false);
        }
    }

    
Return a ContentHandler interface into this serializer. If the serializer does not support the ContentHandler interface, it should return null. 
Throws:
Returns:A ContentHandler interface into this serializer, or null if the serializer is not SAX 2 capable
/**
     * Return a {@link ContentHandler} interface into this serializer.
     * If the serializer does not support the {@link ContentHandler}
     * interface, it should return null.
     *
     * @return A {@link ContentHandler} interface into this serializer,
     *  or null if the serializer is not SAX 2 capable
     * @throws IOException An I/O exception occured
     */
    public ContentHandler asContentHandler() throws IOException {
        return this;
    }

    
Report the end of an entity.

Params:
  • name – The name of the entity that is ending.
Throws:
See Also:
/**
     * Report the end of an entity.
     *
     * @param name The name of the entity that is ending.
     * @throws org.xml.sax.SAXException The application may raise an exception.
     * @see #startEntity
     */
    public void endEntity(String name) throws org.xml.sax.SAXException {
        if (name.equals("[dtd]"))
            m_inExternalDTD = false;

        if (!m_inExternalDTD)
            m_inEntityRef--;

        if (m_tracer != null)
            this.fireEndEntity(name);
    }

    
This method checks if current node is in entity reference.

Returns:True if current node is in entity reference.
/**
     * This method checks if current node is in entity reference.
     *
     * @return True if current node is in entity reference.
     */
    protected boolean isInEntityRef() {
        return m_inEntityRef > 0;
    }

    
Flush and close the underlying java.io.Writer. This method applies to
ToStream serializers, not ToSAXHandler serializers.

See Also:
  • ToStream
/**
     * Flush and close the underlying java.io.Writer. This method applies to
     * ToStream serializers, not ToSAXHandler serializers.
     * @see ToStream
     */
    public void close() {
        // do nothing (base behavior)
    }

    
Initialize global variables

/**
     * Initialize global variables
     */
    protected void initCDATA() {
        // CDATA stack
        // _cdataStack = new Stack();
        // _cdataStack.push(new Integer(-1)); // push dummy value
    }

    
Returns the character encoding to be used in the output document.

Returns:the character encoding to be used in the output document.
/**
     * Returns the character encoding to be used in the output document.
     * @return the character encoding to be used in the output document.
     */
    public String getEncoding() {
        return getOutputProperty(OutputKeys.ENCODING);
    }

   
Sets the character encoding coming from the xsl:output encoding stylesheet attribute.

Params:
  • m_encoding – the character encoding
/**
     * Sets the character encoding coming from the xsl:output encoding stylesheet attribute.
     * @param m_encoding the character encoding
     */
    public void setEncoding(String encoding) {
        setOutputProperty(OutputKeys.ENCODING,encoding);
    }

    
Sets the value coming from the xsl:output omit-xml-declaration stylesheet attribute

Params:
  • b – true if the XML declaration is to be omitted from the output
document.
/**
     * Sets the value coming from the xsl:output omit-xml-declaration stylesheet attribute
     * @param b true if the XML declaration is to be omitted from the output
     * document.
     */
    public void setOmitXMLDeclaration(boolean b) {
        String val = b ? "yes":"no";
        setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,val);
    }

    
Returns:true if the XML declaration is to be omitted from the output
document.
/**
     * @return true if the XML declaration is to be omitted from the output
     * document.
     */
    public boolean getOmitXMLDeclaration() {
        return m_shouldNotWriteXMLHeader;
    }

    
Returns the previously set value of the value to be used as the public
identifier in the document type declaration (DTD).

Returns:the public identifier to be used in the DOCTYPE declaration in the
output document.
/**
     * Returns the previously set value of the value to be used as the public
     * identifier in the document type declaration (DTD).
     *
     *@return the public identifier to be used in the DOCTYPE declaration in the
     * output document.
     */
    public String getDoctypePublic()
    {
        return m_doctypePublic;
    }

    
Set the value coming from the xsl:output doctype-public stylesheet attribute.

Params:
  • doctypePublic – the public identifier to be used in the DOCTYPE
declaration in the output document.
/** Set the value coming from the xsl:output doctype-public stylesheet attribute.
      * @param doctypePublic the public identifier to be used in the DOCTYPE
      * declaration in the output document.
      */
    public void setDoctypePublic(String doctypePublic)
    {
        setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, doctypePublic);
    }


    
Returns the previously set value of the value to be used
as the system identifier in the document type declaration (DTD).

Returns:the system identifier to be used in the DOCTYPE declaration in
the output document.
/**
     * Returns the previously set value of the value to be used
     * as the system identifier in the document type declaration (DTD).
         * @return the system identifier to be used in the DOCTYPE declaration in
         * the output document.
     *
     */
    public String getDoctypeSystem()
    {
        return m_doctypeSystem;
    }

    
Set the value coming from the xsl:output doctype-system stylesheet attribute.

Params:
  • doctypeSystem – the system identifier to be used in the DOCTYPE
declaration in the output document.
/** Set the value coming from the xsl:output doctype-system stylesheet attribute.
      * @param doctypeSystem the system identifier to be used in the DOCTYPE
      * declaration in the output document.
      */
    public void setDoctypeSystem(String doctypeSystem)
    {
        setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doctypeSystem);
    }

    
Set the value coming from the xsl:output doctype-public and doctype-system stylesheet properties

Params:
  • doctypeSystem – the system identifier to be used in the DOCTYPE
declaration in the output document.
  • doctypePublic – the public identifier to be used in the DOCTYPE
declaration in the output document.
/** Set the value coming from the xsl:output doctype-public and doctype-system stylesheet properties
     * @param doctypeSystem the system identifier to be used in the DOCTYPE
     * declaration in the output document.
     * @param doctypePublic the public identifier to be used in the DOCTYPE
     * declaration in the output document.
     */
    public void setDoctype(String doctypeSystem, String doctypePublic)
    {
        setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doctypeSystem);
        setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, doctypePublic);
    }

    
Sets the value coming from the xsl:output standalone stylesheet attribute.

Params:
  • standalone – a value of "yes" indicates that the
standalone delaration is to be included in the output
document. This method remembers if the value was explicitly set using
this method, verses if the value is the default value.
/**
     * Sets the value coming from the xsl:output standalone stylesheet attribute.
     * @param standalone a value of "yes" indicates that the
     * <code>standalone</code> delaration is to be included in the output
     * document. This method remembers if the value was explicitly set using
     * this method, verses if the value is the default value.
     */
    public void setStandalone(String standalone) {
        setOutputProperty(OutputKeys.STANDALONE, standalone);
    }

    
Sets the XSL standalone attribute, but does not remember if this is a
default or explicite setting.

Params:
  • standalone – "yes" | "no"
/**
     * Sets the XSL standalone attribute, but does not remember if this is a
     * default or explicite setting.
     * @param standalone "yes" | "no"
     */
    protected void setStandaloneInternal(String standalone) {
        if ("yes".equals(standalone))
            m_standalone = "yes";
        else
            m_standalone = "no";

    }

    
Gets the XSL standalone attribute

Returns:a value of "yes" if the standalone delaration is to
be included in the output document.
 @see XSLOutputAttributes#getStandalone()
/**
     * Gets the XSL standalone attribute
     * @return a value of "yes" if the <code>standalone</code> delaration is to
     * be included in the output document.
     *  @see XSLOutputAttributes#getStandalone()
     */
    public String getStandalone() {
        return m_standalone;
    }

    
Returns:true if the output document should be indented to visually
indicate its structure.
/**
     * @return true if the output document should be indented to visually
     * indicate its structure.
     */
    public boolean getIndent() {
        return m_doIndent;
    }
    
Gets the mediatype the media-type or MIME type associated with the output
document.

Returns:the mediatype the media-type or MIME type associated with the
output document.
/**
     * Gets the mediatype the media-type or MIME type associated with the output
     * document.
     * @return the mediatype the media-type or MIME type associated with the
     * output document.
     */
    public String getMediaType() {
        return m_mediatype;
    }

    
Gets the version of the output format.

Returns:the version of the output format.
/**
     * Gets the version of the output format.
     * @return the version of the output format.
     */
    public String getVersion() {
        return m_version;
    }

    
Sets the value coming from the xsl:output version attribute.

Params:
  • version – the version of the output format.
See Also:
/**
     * Sets the value coming from the xsl:output version attribute.
     * @param version the version of the output format.
     * @see SerializationHandler#setVersion(String)
     */
    public void setVersion(String version) {
        setOutputProperty(OutputKeys.VERSION, version);
    }

    
Sets the value coming from the xsl:output media-type stylesheet attribute.

Params:
  • mediaType – the non-null media-type or MIME type associated with the
output document.
See Also:
/**
     * Sets the value coming from the xsl:output media-type stylesheet attribute.
     * @param mediaType the non-null media-type or MIME type associated with the
     * output document.
     * @see javax.xml.transform.OutputKeys#MEDIA_TYPE
     * @see SerializationHandler#setMediaType(String)
     */
    public void setMediaType(String mediaType) {
        setOutputProperty(OutputKeys.MEDIA_TYPE,mediaType);
    }

    
Returns:the number of spaces to indent for each indentation level.
/**
     * @return the number of spaces to indent for each indentation level.
     */
    public int getIndentAmount() {
        return m_indentAmount;
    }

    
Sets the indentation amount.

Params:
  • m_indentAmount – The m_indentAmount to set
/**
     * Sets the indentation amount.
     * @param m_indentAmount The m_indentAmount to set
     */
    public void setIndentAmount(int m_indentAmount) {
        this.m_indentAmount = m_indentAmount;
    }

    
Sets the value coming from the xsl:output indent stylesheet
attribute.

Params:
  • doIndent – true if the output document should be indented to
visually indicate its structure.
See Also:
/**
     * Sets the value coming from the xsl:output indent stylesheet
     * attribute.
     * @param doIndent true if the output document should be indented to
     * visually indicate its structure.
     * @see XSLOutputAttributes#setIndent(boolean)
     */
    public void setIndent(boolean doIndent) {
        String val = doIndent ? "yes":"no";
        setOutputProperty(OutputKeys.INDENT,val);
    }

    
Sets the isStandalone property

Params:
  • isStandalone – true if the ORACLE_IS_STANDALONE is set to yes
See Also:
/**
     * Sets the isStandalone property
     * @param isStandalone true if the ORACLE_IS_STANDALONE is set to yes
     * @see OutputPropertiesFactory ORACLE_IS_STANDALONE
     */
    public void setIsStandalone(boolean isStandalone) {
       m_isStandalone = isStandalone;
    }

    
This method is used when a prefix/uri namespace mapping
is indicated after the element was started with a
startElement() and before and endElement().
startPrefixMapping(prefix,uri) would be used before the
startElement() call.

Params:
  • uri – the URI of the namespace
  • prefix – the prefix associated with the given URI.
See Also:
/**
     * This method is used when a prefix/uri namespace mapping
     * is indicated after the element was started with a
     * startElement() and before and endElement().
     * startPrefixMapping(prefix,uri) would be used before the
     * startElement() call.
     * @param uri the URI of the namespace
     * @param prefix the prefix associated with the given URI.
     *
     * @see ExtendedContentHandler#namespaceAfterStartElement(String, String)
     */
    public void namespaceAfterStartElement(String uri, String prefix)
        throws SAXException
    {
        // default behavior is to do nothing
    }

    
Return a DOMSerializer interface into this serializer. If the serializer does not support the DOMSerializer interface, it should return null. 
Throws:
See Also:
Returns:A DOMSerializer interface into this serializer, or null if the serializer is not DOM capable
/**
     * Return a {@link DOMSerializer} interface into this serializer. If the
     * serializer does not support the {@link DOMSerializer} interface, it should
     * return null.
     *
     * @return A {@link DOMSerializer} interface into this serializer,  or null
     * if the serializer is not DOM capable
     * @throws IOException An I/O exception occured
     * @see Serializer#asDOMSerializer()
     */
    public DOMSerializer asDOMSerializer() throws IOException {
        return this;
    }

    
Tell if two strings are equal, without worry if the first string is null.

Params:
  • p – String reference, which may be null.
  • t – String reference, which may be null.
Returns:true if strings are equal.
/**
     * Tell if two strings are equal, without worry if the first string is null.
     *
     * @param p String reference, which may be null.
     * @param t String reference, which may be null.
     *
     * @return true if strings are equal.
     */
    private static final boolean subPartMatch(String p, String t) {
        return (p == t) || ((null != p) && (p.equals(t)));
    }

    
Returns the local name of a qualified name.
If the name has no prefix,
then it works as the identity (SAX2).

Params:
  • qname – a qualified name
Returns:returns the prefix of the qualified name,
or null if there is no prefix.
/**
     * Returns the local name of a qualified name.
     * If the name has no prefix,
     * then it works as the identity (SAX2).
     *
     * @param qname a qualified name
     * @return returns the prefix of the qualified name,
     * or null if there is no prefix.
     */
    protected static final String getPrefixPart(String qname) {
        final int col = qname.indexOf(':');
        return (col > 0) ? qname.substring(0, col) : null;
        //return (col > 0) ? qname.substring(0,col) : "";
    }

    
Some users of the serializer may need the current namespace mappings

See Also:
Returns:the current namespace mappings (prefix/uri)
/**
     * Some users of the serializer may need the current namespace mappings
     * @return the current namespace mappings (prefix/uri)
     * @see ExtendedContentHandler#getNamespaceMappings()
     */
    public NamespaceMappings getNamespaceMappings() {
        return m_prefixMap;
    }

    
Returns the prefix currently pointing to the given URI (if any).

Params:
  • namespaceURI – the uri of the namespace in question
See Also:
Returns:a prefix pointing to the given URI (if any).
/**
     * Returns the prefix currently pointing to the given URI (if any).
     * @param namespaceURI the uri of the namespace in question
     * @return a prefix pointing to the given URI (if any).
     * @see ExtendedContentHandler#getPrefix(String)
     */
    public String getPrefix(String namespaceURI) {
        String prefix = m_prefixMap.lookupPrefix(namespaceURI);
        return prefix;
    }

    
Returns the URI of an element or attribute. Note that default namespaces
do not apply directly to attributes.

Params:
  • qname – a qualified name
  • isElement – true if the qualified name is the name of
an element.
Returns:returns the namespace URI associated with the qualified name.
/**
     * Returns the URI of an element or attribute. Note that default namespaces
     * do not apply directly to attributes.
     * @param qname a qualified name
     * @param isElement true if the qualified name is the name of
     * an element.
     * @return returns the namespace URI associated with the qualified name.
     */
    public String getNamespaceURI(String qname, boolean isElement) {
        String uri = EMPTYSTRING;
        int col = qname.lastIndexOf(':');
        final String prefix = (col > 0) ? qname.substring(0, col) : EMPTYSTRING;

        if (!EMPTYSTRING.equals(prefix) || isElement) {
            if (m_prefixMap != null) {
                uri = m_prefixMap.lookupNamespace(prefix);
                if (uri == null && !prefix.equals(XMLNS_PREFIX)) {
                    throw new RuntimeException(
                        Utils.messages.createMessage(
                            MsgKey.ER_NAMESPACE_PREFIX,
                            new Object[] { qname.substring(0, col) }  ));
                }
            }
        }
        return uri;
    }

    
Returns the URI of prefix (if any)

Params:
  • prefix – the prefix whose URI is searched for
Returns:the namespace URI currently associated with the
prefix, null if the prefix is undefined.
/**
     * Returns the URI of prefix (if any)
     *
         * @param prefix the prefix whose URI is searched for
     * @return the namespace URI currently associated with the
     * prefix, null if the prefix is undefined.
     */
    public String getNamespaceURIFromPrefix(String prefix) {
        String uri = null;
        if (m_prefixMap != null)
            uri = m_prefixMap.lookupNamespace(prefix);
        return uri;
    }

    
Entity reference event.

Params:
  • name – Name of entity
Throws:
/**
     * Entity reference event.
     *
     * @param name Name of entity
     *
     * @throws org.xml.sax.SAXException
     */
    public void entityReference(String name) throws org.xml.sax.SAXException {
        flushPending();

        startEntity(name);
        endEntity(name);

        if (m_tracer != null)
            fireEntityReference(name);
    }

    
Sets the transformer associated with this serializer

Params:
  • t – the transformer associated with this serializer.
See Also:
/**
     * Sets the transformer associated with this serializer
     * @param t the transformer associated with this serializer.
     * @see SerializationHandler#setTransformer(Transformer)
     */
    public void setTransformer(Transformer t) {
        m_transformer = t;

        // If this transformer object implements the SerializerTrace interface
        // then assign m_tracer to the transformer object so it can be used
        // to fire trace events.
        if ((m_transformer instanceof SerializerTrace) &&
            (((SerializerTrace) m_transformer).hasTraceListeners())) {
           m_tracer = (SerializerTrace) m_transformer;
        } else {
           m_tracer = null;
        }
    }

    
Gets the transformer associated with this serializer

See Also:
Returns:returns the transformer associated with this serializer.
/**
     * Gets the transformer associated with this serializer
     * @return returns the transformer associated with this serializer.
     * @see SerializationHandler#getTransformer()
     */
    public Transformer getTransformer() {
        return m_transformer;
    }

    
This method gets the nodes value as a String and uses that String as if
it were an input character notification.

Params:
  • node – the Node to serialize
Throws:
/**
     * This method gets the nodes value as a String and uses that String as if
     * it were an input character notification.
     * @param node the Node to serialize
     * @throws org.xml.sax.SAXException
     */
    public void characters(org.w3c.dom.Node node)
        throws org.xml.sax.SAXException
    {
        flushPending();
        String data = node.getNodeValue();
        if (data != null) {
            final int length = data.length();
            if (length > m_charsBuff.length) {
                m_charsBuff = new char[length * 2 + 1];
            }
            data.getChars(0, length, m_charsBuff, 0);
            characters(m_charsBuff, 0, length);
        }
    }


    
See Also:
  • error.error(SAXParseException)
/**
     * @see org.xml.sax.ErrorHandler#error(SAXParseException)
     */
    public void error(SAXParseException exc) throws SAXException {
    }

    
See Also:
  • fatalError.fatalError(SAXParseException)
/**
     * @see org.xml.sax.ErrorHandler#fatalError(SAXParseException)
     */
    public void fatalError(SAXParseException exc) throws SAXException {
        m_elemContext.m_startTagOpen = false;
    }

    
See Also:
  • warning.warning(SAXParseException)
/**
     * @see org.xml.sax.ErrorHandler#warning(SAXParseException)
     */
    public void warning(SAXParseException exc) throws SAXException {
    }

    
To fire off start entity trace event

Params:
  • name – Name of entity
/**
     * To fire off start entity trace event
     * @param name Name of entity
     */
    protected void fireStartEntity(String name)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
        {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENTITYREF, name);
        }
    }

    
This method is only used internally when flushing the writer from the
various fire...() trace events.  Due to the writer being wrapped with
SerializerTraceWriter it may cause the flush of these trace events:
EVENTTYPE_OUTPUT_PSEUDO_CHARACTERS
EVENTTYPE_OUTPUT_CHARACTERS
which trace the output written to the output stream.

/**
     * This method is only used internally when flushing the writer from the
     * various fire...() trace events.  Due to the writer being wrapped with
     * SerializerTraceWriter it may cause the flush of these trace events:
     * EVENTTYPE_OUTPUT_PSEUDO_CHARACTERS
     * EVENTTYPE_OUTPUT_CHARACTERS
     * which trace the output written to the output stream.
     *
     */
    private void flushMyWriter() {
        if (m_writer != null) {
            try {
                m_writer.flush();
            } catch(IOException ioe) {
            }
        }
    }

    
Report the CDATA trace event

Params:
  • chars –  content of CDATA
  • start –  starting index of characters to output
  • length –  number of characters to output
/**
     * Report the CDATA trace event
     * @param chars  content of CDATA
     * @param start  starting index of characters to output
     * @param length  number of characters to output
     */
    protected void fireCDATAEvent(char[] chars, int start, int length)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null) {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CDATA, chars, start,length);
        }
    }

    
Report the comment trace event

Params:
  • chars –  content of comment
  • start –  starting index of comment to output
  • length –  number of characters to output
/**
     * Report the comment trace event
     * @param chars  content of comment
     * @param start  starting index of comment to output
     * @param length  number of characters to output
     */
    protected void fireCommentEvent(char[] chars, int start, int length)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null) {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_COMMENT, new String(chars, start, length));
        }
    }


    
To fire off end entity trace event

Params:
  • name – Name of entity
/**
     * To fire off end entity trace event
     * @param name Name of entity
     */
    public void fireEndEntity(String name)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
            flushMyWriter();
        // we do not need to handle this.
    }

    
To fire off start document trace  event

/**
     * To fire off start document trace  event
     */
     protected void fireStartDoc()
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
        {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_STARTDOCUMENT);
        }
    }


    
To fire off end document trace event

/**
     * To fire off end document trace event
     */
    protected void fireEndDoc()
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
        {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENDDOCUMENT);
        }
    }

    
Report the start element trace event. This trace method needs to be
called just before the attributes are cleared.

Params:
  • elemName – the qualified name of the element
/**
     * Report the start element trace event. This trace method needs to be
     * called just before the attributes are cleared.
     *
     * @param elemName the qualified name of the element
     *
     */
    protected void fireStartElem(String elemName)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
        {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_STARTELEMENT,
                elemName, m_attributes);
        }
    }


    /**
     * To fire off the end element event
     * @param name Name of element
     */
//    protected void fireEndElem(String name)
//        throws org.xml.sax.SAXException
//    {
//        if (m_tracer != null)
//            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENDELEMENT,name, (Attributes)null);
//    }


    
To fire off the PI trace event

Params:
  • name – Name of PI
/**
     * To fire off the PI trace event
     * @param name Name of PI
     */
    protected void fireEscapingEvent(String name, String data)
        throws org.xml.sax.SAXException
    {

        if (m_tracer != null)
        {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_PI,name, data);
        }
    }


    
To fire off the entity reference trace event

Params:
  • name – Name of entity reference
/**
     * To fire off the entity reference trace event
     * @param name Name of entity reference
     */
    protected void fireEntityReference(String name)
        throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
        {
            flushMyWriter();
            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENTITYREF,name, (Attributes)null);
        }
    }

    
Receive notification of the beginning of a document.
This method is never a self generated call,
but only called externally.

The SAX parser will invoke this method only once, before any
other methods in this interface or in DTDHandler (except for
setDocumentLocator).


Throws:
  • SAXException – Any SAX exception, possibly
           wrapping another exception.
  • SAXException – 
/**
     * Receive notification of the beginning of a document.
     * This method is never a self generated call,
     * but only called externally.
     *
     * <p>The SAX parser will invoke this method only once, before any
     * other methods in this interface or in DTDHandler (except for
     * setDocumentLocator).</p>
     *
     * @throws org.xml.sax.SAXException Any SAX exception, possibly
     *            wrapping another exception.
     *
     * @throws org.xml.sax.SAXException
     */
    public void startDocument() throws org.xml.sax.SAXException
    {

        // if we do get called with startDocument(), handle it right away
        startDocumentInternal();
        m_needToCallStartDocument = false;
        return;
    }

    
This method handles what needs to be done at a startDocument() call,
whether from an external caller, or internally called in the
serializer.  For historical reasons the serializer is flexible to
startDocument() not always being called.
Even if no external call is
made into startDocument() this method will always be called as a self
generated internal startDocument, it handles what needs to be done at a
startDocument() call.
This method exists just to make sure that startDocument() is only ever
called from an external caller, which in principle is just a matter of
style.

Throws:
  • SAXException – 
/**
     * This method handles what needs to be done at a startDocument() call,
     * whether from an external caller, or internally called in the
     * serializer.  For historical reasons the serializer is flexible to
     * startDocument() not always being called.
     * Even if no external call is
     * made into startDocument() this method will always be called as a self
     * generated internal startDocument, it handles what needs to be done at a
     * startDocument() call.
     *
     * This method exists just to make sure that startDocument() is only ever
     * called from an external caller, which in principle is just a matter of
     * style.
     *
     * @throws SAXException
     */
    protected void startDocumentInternal() throws org.xml.sax.SAXException
    {
        if (m_tracer != null)
            this.fireStartDoc();

    }

    /* This method extracts version and encoding information from SAX events.
     */
    protected void setDocumentInfo() {
        if (m_locator == null)
                return;
        try{
            String strVersion = ((Locator2)m_locator).getXMLVersion();
            if (strVersion != null)
                setVersion(strVersion);
            /*String strEncoding = ((Locator2)m_locator).getEncoding();
            if (strEncoding != null)
                setEncoding(strEncoding); */

        }catch(ClassCastException e){}
    }

    
This method is used to set the source locator, which might be used to
generated an error message.

Params:
  • locator – the source locator
See Also:
/**
     * This method is used to set the source locator, which might be used to
     * generated an error message.
     * @param locator the source locator
     *
     * @see ExtendedContentHandler#setSourceLocator(javax.xml.transform.SourceLocator)
     */
    public void setSourceLocator(SourceLocator locator) {
        m_sourceLocator = locator;
    }

    
Used only by TransformerSnapshotImpl to restore the serialization
to a previous state.

Params:
  • mappings – NamespaceMappings
/**
     * Used only by TransformerSnapshotImpl to restore the serialization
     * to a previous state.
     *
     * @param mappings NamespaceMappings
     */
    public void setNamespaceMappings(NamespaceMappings mappings) {
        m_prefixMap = mappings;
    }

    public boolean reset() {
        resetSerializerBase();
        return true;
    }

    
Reset all of the fields owned by SerializerBase

/**
     * Reset all of the fields owned by SerializerBase
     *
     */
    private void resetSerializerBase() {
        this.m_attributes.clear();
        this.m_StringOfCDATASections = null;
        this.m_elemContext = new ElemContext();
        this.m_doctypePublic = null;
        this.m_doctypeSystem = null;
        this.m_doIndent = false;
        this.m_indentAmount = 4;
        this.m_inEntityRef = 0;
        this.m_inExternalDTD = false;
        this.m_mediatype = null;
        this.m_needToCallStartDocument = true;
        this.m_needToOutputDocTypeDecl = false;
        if (this.m_prefixMap != null)
            this.m_prefixMap.reset();
        this.m_shouldNotWriteXMLHeader = false;
        this.m_sourceLocator = null;
        this.m_standalone = null;
        this.m_standaloneWasSpecified = false;
        this.m_tracer = null;
        this.m_transformer = null;
        this.m_version = null;
        // don't set writer to null, so that it might be re-used
        //this.m_writer = null;
    }

    
Returns true if the serializer is used for temporary output rather than
final output.
This concept is made clear in the XSLT 2.0 draft.

/**
     * Returns true if the serializer is used for temporary output rather than
     * final output.
     *
     * This concept is made clear in the XSLT 2.0 draft.
     */
    final boolean inTemporaryOutputState() {
        /* This is a hack. We should really be letting the serializer know
         * that it is in temporary output state with an explicit call, but
         * from a pragmatic point of view (for now anyways) having no output
         * encoding at all, not even the default UTF-8 indicates that the
         * serializer is being used for temporary RTF.
         */
        return (getEncoding() == null);

    }

    
This method adds an attribute the the current element,
but should not be used for an xsl:attribute child.

See Also:
  • addAttribute.addAttribute(String, String, String, String, String)
/**
     * This method adds an attribute the the current element,
     * but should not be used for an xsl:attribute child.
     * @see ExtendedContentHandler#addAttribute(java.lang.String, java.lang.String,
     *          java.lang.String, java.lang.String, java.lang.String)
     */
    public void addAttribute(String uri, String localName, String rawName,
                             String type, String value) throws SAXException
    {
        if (m_elemContext.m_startTagOpen) {
            addAttributeAlways(uri, localName, rawName, type, value, false);
        }
    }

    
See Also:
  • notationDecl.notationDecl(String, String, String)
/**
     * @see org.xml.sax.DTDHandler#notationDecl(java.lang.String,
     *          java.lang.String, java.lang.String)
     */
    public void notationDecl(String arg0, String arg1, String arg2)
        throws SAXException
    {
        // This method just provides a definition to satisfy the interface
        // A particular sub-class of SerializerBase provides the implementation
        // (if desired)
    }

    
See Also:
  • unparsedEntityDecl.unparsedEntityDecl(String, String, String, String)
/**
     * @see org.xml.sax.DTDHandler#unparsedEntityDecl(java.lang.String,
     *          java.lang.String, java.lang.String, java.lang.String)
     */
    public void unparsedEntityDecl(String arg0, String arg1, String arg2,
                                   String arg3) throws SAXException {
        // This method just provides a definition to satisfy the interface
        // A particular sub-class of SerializerBase provides the implementation
        // (if desired)
    }

    
If set to false the serializer does not expand DTD entities,
but leaves them as is, the default value is true.

/**
     * If set to false the serializer does not expand DTD entities,
     * but leaves them as is, the default value is true.
     */
    public void setDTDEntityExpansion(boolean expand) {
        // This method just provides a definition to satisfy the interface
        // A particular sub-class of SerializerBase provides the implementation (if desired)
    }


    
The CDATA section names stored in a whitespace separateed list with
each element being a word of the form "{uri}localName" This list
comes from the cdata-section-elements attribute.
This field replaces m_cdataSectionElements Vector.

/**
     * The CDATA section names stored in a whitespace separateed list with
     * each element being a word of the form "{uri}localName" This list
     * comes from the cdata-section-elements attribute.
     *
     * This field replaces m_cdataSectionElements Vector.
     */
    protected String m_StringOfCDATASections = null;

    boolean m_docIsEmpty = true;
    void initCdataElems(String s)
    {
        if (s != null)
        {
            int max = s.length();

            // true if we are in the middle of a pair of curly braces that delimit a URI
            boolean inCurly = false;

            // true if we found a URI but haven't yet processed the local name
            boolean foundURI = false;

            StringBuilder buf = new StringBuilder();
            String uri = null;
            String localName = null;

            // parse through string, breaking on whitespaces.  I do this instead
            // of a tokenizer so I can track whitespace inside of curly brackets,
            // which theoretically shouldn't happen if they contain legal URLs.
            for (int i = 0; i < max; i++)
            {
                char c = s.charAt(i);

                if (Character.isWhitespace(c))
                {
                    if (!inCurly)
                    {
                        if (buf.length() > 0)
                        {
                            localName = buf.toString();
                            if (!foundURI)
                                uri = "";
                            addCDATAElement(uri,localName);
                            buf.setLength(0);
                            foundURI = false;
                        }
                        continue;
                    }
                    else
                        buf.append(c); // add whitespace to the URI
                }
                else if ('{' == c) // starting a URI
                    inCurly = true;
                else if ('}' == c)
                {
                    // we just ended a URI
                    foundURI = true;
                    uri = buf.toString();
                    buf.setLength(0);
                    inCurly = false;
                }
                else
                {
                    // append non-whitespace, non-curly to current URI or localName being gathered.
                    buf.append(c);
                }

            }

            if (buf.length() > 0)
            {
                // We have one last localName to process.
                localName = buf.toString();
                if (!foundURI)
                    uri = "";
                addCDATAElement(uri,localName);
            }
        }
    }

    protected java.util.HashMap<String, HashMap<String, String>> m_CdataElems = null;
    private void addCDATAElement(String uri, String localName)
    {
        if (m_CdataElems == null) {
            m_CdataElems = new java.util.HashMap<>();
        }

        HashMap<String,String> h = m_CdataElems.get(localName);
        if (h == null) {
            h = new HashMap<>();
            m_CdataElems.put(localName,h);
        }
        h.put(uri,uri);

    }


    
Return true if nothing has been sent to this result tree yet.


This is not a public API.

@xsl.usageinternal
/**
     * Return true if nothing has been sent to this result tree yet.
     * <p>
     * This is not a public API.
     *
     * @xsl.usage internal
     */
    public boolean documentIsEmpty() {
        // If we haven't called startDocument() yet, then this document is empty
        return m_docIsEmpty && (m_elemContext.m_currentElemDepth == 0);
    }

    
Return true if the current element in m_elemContext
is a CDATA section.
CDATA sections are specified in the  attribute
cdata-section-names or in the JAXP equivalent property.
In any case the format of the value of such a property is:

"{uri1}localName1 {uri2}localName2 . . . "




This method is not a public API, but is only used internally by the serializer.

/**
     * Return true if the current element in m_elemContext
     * is a CDATA section.
     * CDATA sections are specified in the <xsl:output> attribute
     * cdata-section-names or in the JAXP equivalent property.
     * In any case the format of the value of such a property is:
     * <pre>
     * "{uri1}localName1 {uri2}localName2 . . . "
     * </pre>
     *
     * <p>
     * This method is not a public API, but is only used internally by the serializer.
     */
    protected boolean isCdataSection() {
        boolean b = false;

        if (null != m_StringOfCDATASections) {
            if (m_elemContext.m_elementLocalName == null) {
                String localName =  getLocalName(m_elemContext.m_elementName);
                m_elemContext.m_elementLocalName = localName;
            }

            if ( m_elemContext.m_elementURI == null) {

                m_elemContext.m_elementURI = getElementURI();
            }
            else if ( m_elemContext.m_elementURI.length() == 0) {
                if ( m_elemContext.m_elementName == null) {
                    m_elemContext.m_elementName = m_elemContext.m_elementLocalName;
                    // leave URI as "", meaning in no namespace
                }
                else if (m_elemContext.m_elementLocalName.length() < m_elemContext.m_elementName.length()){
                    // We were told the URI was "", yet the name has a prefix since the name is longer than the localname.
                    // So we will fix that incorrect information here.
                    m_elemContext.m_elementURI = getElementURI();
                }
            }

            HashMap<String, String> h = null;
            if (m_CdataElems != null) {
                h = m_CdataElems.get(m_elemContext.m_elementLocalName);
            }
            if (h != null) {
                Object obj = h.get(m_elemContext.m_elementURI);
                if (obj != null)
                    b = true;
            }

        }
        return b;
    }

    
Before this call m_elementContext.m_elementURI is null,
which means it is not yet known. After this call it
is non-null, but possibly "" meaning that it is in the
default namespace.

Returns:The URI of the element, never null, but possibly "".
/**
     * Before this call m_elementContext.m_elementURI is null,
     * which means it is not yet known. After this call it
     * is non-null, but possibly "" meaning that it is in the
     * default namespace.
     *
     * @return The URI of the element, never null, but possibly "".
     */
    private String getElementURI() {
        String uri = null;
        // At this point in processing we have received all the
        // namespace mappings
        // As we still don't know the elements namespace,
        // we now figure it out.

        String prefix = getPrefixPart(m_elemContext.m_elementName);

        if (prefix == null) {
            // no prefix so lookup the URI of the default namespace
            uri = m_prefixMap.lookupNamespace("");
        } else {
            uri = m_prefixMap.lookupNamespace(prefix);
        }
        if (uri == null) {
            // We didn't find the namespace for the
            // prefix ... ouch, that shouldn't happen.
            // This is a hack, we really don't know
            // the namespace
            uri = EMPTYSTRING;
        }

        return uri;
    }


    
Get the value of an output property,
the explicit value, if any, otherwise the
default value, if any, otherwise null.

/**
     * Get the value of an output property,
     * the explicit value, if any, otherwise the
     * default value, if any, otherwise null.
     */
    public String getOutputProperty(String name) {
        String val = getOutputPropertyNonDefault(name);
        // If no explicit value, try to get the default value
        if (val == null)
            val = getOutputPropertyDefault(name);
        return val;

    }
    
Get the value of an output property,
not the default value. If there is a default
value, but no non-default value this method
will return null.



/**
     * Get the value of an output property,
     * not the default value. If there is a default
     * value, but no non-default value this method
     * will return null.
     * <p>
     *
     */
    public String getOutputPropertyNonDefault(String name) {
        return getProp(name,false);
    }

    
Return a DOM3Serializer interface into this serializer. If the serializer does not support the DOM3Serializer interface, it should return null. 
Throws:
See Also:
  • asDOM3Serializer.asDOM3Serializer()
Returns:A DOM3Serializer interface into this serializer, or null if the serializer is not DOM capable
/**
     * Return a {@link DOM3Serializer} interface into this serializer. If the
     * serializer does not support the {@link DOM3Serializer} interface, it should
     * return null.
     *
     * @return A {@link DOM3Serializer} interface into this serializer,  or null
     * if the serializer is not DOM capable
     * @throws IOException An I/O exception occured
     * @see org.apache.xml.serializer.Serializer#asDOM3Serializer()
     */
    public Object asDOM3Serializer() throws IOException
    {
        return new com.sun.org.apache.xml.internal.serializer.dom3.DOM3SerializerImpl(this);
    }

    
Get the default value of an xsl:output property,
which would be null only if no default value exists
for the property.

/**
     * Get the default value of an xsl:output property,
     * which would be null only if no default value exists
     * for the property.
     */
    public String getOutputPropertyDefault(String name) {
        return getProp(name, true);
    }

    
Set the value for the output property, typically from
an xsl:output element, but this does not change what
the default value is.

/**
     * Set the value for the output property, typically from
     * an xsl:output element, but this does not change what
     * the default value is.
     */
    public void setOutputProperty(String name, String val) {
        setProp(name,val,false);
    }

    
Set the default value for an output property, but this does
not impact any explicitly set value.

/**
     * Set the default value for an output property, but this does
     * not impact any explicitly set value.
     */
    public void setOutputPropertyDefault(String name, String val) {
        setProp(name,val,true);

    }

    
A mapping of keys to explicitly set values, for example if
and  has an "encoding" attribute, this
map will have what that attribute maps to.

/**
     * A mapping of keys to explicitly set values, for example if
     * and <xsl:output/> has an "encoding" attribute, this
     * map will have what that attribute maps to.
     */
    private HashMap<String, String> m_OutputProps;

    
A mapping of keys to default values, for example if
the default value of the encoding is "UTF-8" then this
map will have that "encoding" maps to "UTF-8".

/**
     * A mapping of keys to default values, for example if
     * the default value of the encoding is "UTF-8" then this
     * map will have that "encoding" maps to "UTF-8".
     */
    private HashMap<String, String> m_OutputPropsDefault;

    Set<String> getOutputPropDefaultKeys() {
        return m_OutputPropsDefault.keySet();
    }

    Set<String> getOutputPropKeys() {
        return m_OutputProps.keySet();
    }

    private String getProp(String name, boolean defaultVal) {
        if (m_OutputProps == null) {
            m_OutputProps = new HashMap<>();
            m_OutputPropsDefault = new HashMap<>();
        }

        String val;
        if (defaultVal)
            val = m_OutputPropsDefault.get(name);
        else
            val = m_OutputProps.get(name);

        return val;
    }

    
Params:
  • name – The name of the property, e.g. "{http://myprop}indent-tabs" or "indent".
  • val – The value of the property, e.g. "4"
  • defaultVal – true if this is a default value being set for the property as
opposed to a user define on, set say explicitly in the stylesheet or via JAXP
/**
     *
     * @param name The name of the property, e.g. "{http://myprop}indent-tabs" or "indent".
     * @param val The value of the property, e.g. "4"
     * @param defaultVal true if this is a default value being set for the property as
     * opposed to a user define on, set say explicitly in the stylesheet or via JAXP
     */
    void setProp(String name, String val, boolean defaultVal) {
        if (m_OutputProps == null) {
            m_OutputProps = new HashMap<>();
            m_OutputPropsDefault = new HashMap<>();
        }

        if (defaultVal)
            m_OutputPropsDefault.put(name,val);
        else {
            if (OutputKeys.CDATA_SECTION_ELEMENTS.equals(name) && val != null) {
                initCdataElems(val);
                String oldVal = m_OutputProps.get(name);
                String newVal;
                if (oldVal == null)
                    newVal = oldVal + ' ' + val;
                else
                    newVal = val;
                m_OutputProps.put(name,newVal);
            }
            else {
                m_OutputProps.put(name,val);
            }
        }
    }

    
Get the first char of the local name

Params:
  • name – Either a local name, or a local name
preceeded by a uri enclosed in curly braces.
/**
     * Get the first char of the local name
     * @param name Either a local name, or a local name
     * preceeded by a uri enclosed in curly braces.
     */
    static char getFirstCharLocName(String name) {
        final char first;
        int i = name.indexOf('}');
        if (i < 0)
            first = name.charAt(0);
        else
            first = name.charAt(i+1);
        return first;
    }
}