| Methods Summary |
|---|
| public void | CopyFrom(com.sun.org.apache.xml.internal.serializer.ToXMLStream xmlListener)Copy properties from another SerializerToXML.
m_writer = xmlListener.m_writer;
// m_outputStream = xmlListener.m_outputStream;
String encoding = xmlListener.getEncoding();
setEncoding(encoding);
setOmitXMLDeclaration(xmlListener.getOmitXMLDeclaration());
m_ispreserve = xmlListener.m_ispreserve;
m_preserves = xmlListener.m_preserves;
m_isprevtext = xmlListener.m_isprevtext;
m_doIndent = xmlListener.m_doIndent;
setIndentAmount(xmlListener.getIndentAmount());
m_startNewLine = xmlListener.m_startNewLine;
m_needToOutputDocTypeDecl = xmlListener.m_needToOutputDocTypeDecl;
setDoctypeSystem(xmlListener.getDoctypeSystem());
setDoctypePublic(xmlListener.getDoctypePublic());
setStandalone(xmlListener.getStandalone());
setMediaType(xmlListener.getMediaType());
m_maxCharacter = xmlListener.m_maxCharacter;
m_spaceBeforeClose = xmlListener.m_spaceBeforeClose;
m_cdataStartCalled = xmlListener.m_cdataStartCalled;
|
| public void | addAttribute(java.lang.String uri, java.lang.String localName, java.lang.String rawName, java.lang.String type, java.lang.String value)
if (m_elemContext.m_startTagOpen)
{
if (!rawName.startsWith("xmlns"))
{
String prefixUsed =
ensureAttributesNamespaceIsDeclared(
uri,
localName,
rawName);
if (prefixUsed != null
&& rawName != null
&& !rawName.startsWith(prefixUsed))
{
// use a different raw name, with the prefix used in the
// generated namespace declaration
rawName = prefixUsed + ":" + localName;
}
}
addAttributeAlways(uri, localName, rawName, type, value);
}
else
{
/*
* The startTag is closed, yet we are adding an attribute?
*
* Section: 7.1.3 Creating Attributes Adding an attribute to an
* element after a PI (for example) has been added to it is an
* error. The attributes can be ignored. The spec doesn't explicitly
* say this is disallowed, as it does for child elements, but it
* makes sense to have the same treatment.
*
* We choose to ignore the attribute which is added too late.
*/
// Generate a warning of the ignored attributes
// Create the warning message
String msg = XMLMessages.createXMLMessage(
XMLErrorResources.ER_ILLEGAL_ATTRIBUTE_POSITION,new Object[]{ localName });
try {
// Prepare to issue the warning message
Transformer tran = super.getTransformer();
ErrorListener errHandler = tran.getErrorListener();
// Issue the warning message
if (null != errHandler && m_sourceLocator != null)
errHandler.warning(new TransformerException(msg, m_sourceLocator));
else
System.out.println(msg);
}
catch (Exception e){}
}
|
| public void | addUniqueAttribute(java.lang.String name, java.lang.String value, int flags)This method is used to add an attribute to the currently open element.
The caller has guaranted that this attribute is unique, which means that it
not been seen before and will not be seen again.
if (m_elemContext.m_startTagOpen)
{
try
{
final String patchedName = patchName(name);
final java.io.Writer writer = m_writer;
if ((flags & NO_BAD_CHARS) > 0 && m_xmlcharInfo.onlyQuotAmpLtGt)
{
// "flags" has indicated that the characters
// '>' '<' '&' and '"' are not in the value and
// m_htmlcharInfo has recorded that there are no other
// entities in the range 32 to 127 so we write out the
// value directly
writer.write(' ");
writer.write(patchedName);
writer.write("=\"");
writer.write(value);
writer.write('"");
}
else
{
writer.write(' ");
writer.write(patchedName);
writer.write("=\"");
writeAttrString(writer, value, this.getEncoding());
writer.write('"");
}
} catch (IOException e) {
throw new SAXException(e);
}
}
|
| public void | endDocument()Receive notification of the end of a document.
flushPending();
if (m_doIndent && !m_isprevtext)
{
try
{
outputLineSep();
}
catch(IOException e)
{
throw new SAXException(e);
}
}
flushWriter();
if (m_tracer != null)
super.fireEndDoc();
|
| public void | endElement(java.lang.String elemName)
endElement(null, null, elemName);
|
| public void | endPreserving()Ends a whitespace preserving section.
// Not sure this is really what we want. -sb
m_ispreserve = m_preserves.isEmpty() ? false : m_preserves.pop();
|
| public void | entityReference(java.lang.String name)Receive notivication of a entityReference.
if (m_elemContext.m_startTagOpen)
{
closeStartTag();
m_elemContext.m_startTagOpen = false;
}
try
{
if (shouldIndent())
indent();
final java.io.Writer writer = m_writer;
writer.write('&");
writer.write(name);
writer.write(';");
}
catch(IOException e)
{
throw new SAXException(e);
}
if (m_tracer != null)
super.fireEntityReference(name);
|
| public void | namespaceAfterStartElement(java.lang.String prefix, java.lang.String uri)From XSLTC
Related to startPrefixMapping ???
// hack for XSLTC with finding URI for default namespace
if (m_elemContext.m_elementURI == null)
{
String prefix1 = getPrefixPart(m_elemContext.m_elementName);
if (prefix1 == null && EMPTYSTRING.equals(prefix))
{
// the elements URI is not known yet, and it
// doesn't have a prefix, and we are currently
// setting the uri for prefix "", so we have
// the uri for the element... lets remember it
m_elemContext.m_elementURI = uri;
}
}
startPrefixMapping(prefix,uri,false);
return;
|
| public void | processingInstruction(java.lang.String target, java.lang.String data)Receive notification of a processing instruction.
if (m_inEntityRef)
return;
flushPending();
if (target.equals(Result.PI_DISABLE_OUTPUT_ESCAPING))
{
startNonEscaping();
}
else if (target.equals(Result.PI_ENABLE_OUTPUT_ESCAPING))
{
endNonEscaping();
}
else
{
try
{
if (m_elemContext.m_startTagOpen)
{
closeStartTag();
m_elemContext.m_startTagOpen = false;
}
if (shouldIndent())
indent();
final java.io.Writer writer = m_writer;
writer.write("<?");
writer.write(target);
if (data.length() > 0
&& !Character.isSpaceChar(data.charAt(0)))
writer.write(' ");
int indexOfQLT = data.indexOf("?>");
if (indexOfQLT >= 0)
{
// See XSLT spec on error recovery of "?>" in PIs.
if (indexOfQLT > 0)
{
writer.write(data.substring(0, indexOfQLT));
}
writer.write("? >"); // add space between.
if ((indexOfQLT + 2) < data.length())
{
writer.write(data.substring(indexOfQLT + 2));
}
}
else
{
writer.write(data);
}
writer.write('?");
writer.write('>");
// Always output a newline char if not inside of an
// element. The whitespace is not significant in that
// case.
if (m_elemContext.m_currentElemDepth <= 0)
writer.write(m_lineSep, 0, m_lineSepLen);
m_startNewLine = true;
}
catch(IOException e)
{
throw new SAXException(e);
}
}
if (m_tracer != null)
super.fireEscapingEvent(target, data);
|
| protected boolean | pushNamespace(java.lang.String prefix, java.lang.String uri)From XSLTC
Declare a prefix to point to a namespace URI. Inform SAX handler
if this is a new prefix mapping.
try
{
if (m_prefixMap.pushNamespace(
prefix, uri, m_elemContext.m_currentElemDepth))
{
startPrefixMapping(prefix, uri);
return true;
}
}
catch (SAXException e)
{
// falls through
}
return false;
|
| public boolean | reset()Try's to reset the super class and reset this class for
re-use, so that you don't need to create a new serializer
(mostly for performance reasons).
boolean wasReset = false;
if (super.reset())
{
resetToXMLStream();
wasReset = true;
}
return wasReset;
|
| private void | resetToXMLStream()Reset all of the fields owned by ToStream class
this.m_cdataTagOpen = false;
|
| public void | startDocumentInternal()Receive notification of the beginning of a document.
if (m_needToCallStartDocument)
{
super.startDocumentInternal();
m_needToCallStartDocument = false;
if (m_inEntityRef)
return;
m_needToOutputDocTypeDecl = true;
m_startNewLine = false;
if (getOmitXMLDeclaration() == false)
{
String encoding = Encodings.getMimeEncoding(getEncoding());
String version = getVersion();
if (version == null)
version = "1.0";
String standalone;
if (m_standaloneWasSpecified)
{
standalone = " standalone=\"" + getStandalone() + "\"";
}
else
{
standalone = "";
}
try
{
final java.io.Writer writer = m_writer;
writer.write("<?xml version=\"");
writer.write(version);
writer.write("\" encoding=\"");
writer.write(encoding);
writer.write('\"");
writer.write(standalone);
writer.write("?>");
if (m_doIndent)
writer.write(m_lineSep, 0, m_lineSepLen);
}
catch(IOException e)
{
throw new SAXException(e);
}
}
}
|
| public void | startPreserving()Starts a whitespace preserving section. All characters printed
within a preserving section are printed without indentation and
without consolidating multiple spaces. This is equivalent to
the xml:space="preserve" attribute. Only XML
and HTML serializers need to support this method.
The contents of the whitespace preserving section will be delivered
through the regular characters event.
// Not sure this is really what we want. -sb
m_preserves.push(true);
m_ispreserve = true;
|
