Examples of DOMSerializer

org.apache.ws.commons.serialize.DOMSerializer
Serializes a DOM node into a stream of SAX events.
org.apache.ws.jaxme.util.DOMSerializer

Serializes a DOM node into a stream of SAX events.
@author Jochen Wiedmann @version $Id: DOMSerializer.java,v 1.3 2003/10/27 13:55:53 jochen Exp $
org.apache.xalan.serialize.DOMSerializer
@deprecated Use org.apache.xml.serializer.DOMSerializer
org.apache.xml.serialize.DOMSerializer
Interface for a DOM serializer implementation. @version $Revision: 1.3 $ $Date: 2000/08/30 18:59:19 $ @author Scott Boag @author Assaf Arkin
org.apache.xml.serializer.DOMSerializer
te a document to be serialized org.w3c.dom.Document doc = ...; // Create a Serializer that will be used // to serialize the document org.apache.xml.serializer.Serializer ser = ...; // Set the Writer to write output to, and // serialize the DOM using that Serializer java.io.StringWriter sw = new java.io.StringWriter(); ser.setWriter(sw); DOMSerialzier dser = ser.asDOMSerializer(); dser.serialize(doc); // Write out the serialized XML in the String. System.out.println(sw.toString()); @see OutputPropertiesFactory @see SerializerFactory @see Serializer @xsl.usage general
org.exist.util.serializer.DOMSerializer
org.htmlcleaner.DomSerializer

DOM serializer - creates xml DOM.
org.w3c.dom.ls.DOMSerializer
3.org/TR/2003/WD-DOM-Level-3-Core-20030609'>DOM Level 3 Core] , Appendix B. [DOM Level 2 Core] allows empty strings as a real namespace URI. If the namespaceURI of a Node is empty string, the serialization will treat them as null, ignoring the prefix if any.
DOMSerializer accepts any node type for serialization. For nodes of type Document or Entity, well-formed XML will be created when possible (well-formedness is guaranteed if the document or entity comes from a parse operation and is unchanged since it was created). The serialized output for these node types is either as a XML document or an External XML Entity, respectively, and is acceptable input for an XML parser. For all other types of nodes the serialized form is not specified, but should be something useful to a human for debugging or diagnostic purposes.
Within a Document, DocumentFragment, or Entity being serialized, Nodes are processed as follows
- Document nodes are written, including the XML declaration (unless the parameter "xml-declaration" is set to false) and a DTD subset, if one exists in the DOM. Writing a Document node serializes the entire document.
- Entity nodes, when written directly by DOMSerializer.write, outputs the entity expansion but no namespace fixup is done. The resulting output will be valid as an external entity.
- EntityReference nodes are serialized as an entity reference of the form "&entityName;" in the output. Child nodes (the expansion) of the entity reference are ignored.
- CDATA sections containing content characters that cannot be represented in the specified output encoding are handled according to the " split-cdata-sections" parameter. If the parameter is set to true, CDATA sections are split, and the unrepresentable characters are serialized as numeric character references in ordinary content. The exact position and number of splits is not specified. If the parameter is set to false , unrepresentable characters in a CDATA section are reported as "invalid-data-in-cdata-section" errors. The error is not recoverable - there is no mechanism for supplying alternative characters and continuing with the serialization.
- DocumentFragment nodes are serialized by serializing the children of the document fragment in the order they appear in the document fragment.
- All other node types (Element, Text, etc.) are serialized to their corresponding XML source form.
Note: The serialization of a Node does not always generate a well-formed XML document, i.e. a DOMParser might throw fatal errors when parsing the resulting serialization.
Within the character data of a document (outside of markup), any characters that cannot be represented directly are replaced with character references. Occurrences of '<' and '&' are replaced by the predefined entities < and &. The other predefined entities (>, ', and ") might not be used, except where needed (e.g. using > in cases such as ']]>'). Any characters that cannot be represented directly in the output character encoding are serialized as numeric character references.
To allow attribute values to contain both single and double quotes, the apostrophe or single-quote character (') may be represented as "'", and the double-quote character (") as """. New line characters and other characters that cannot be represented directly in attribute values in the output character encoding are serialized as a numeric character reference.
Within markup, but outside of attributes, any occurrence of a character that cannot be represented in the output character encoding is reported as an error. An example would be serializing the element <LaCa\u00f1ada/> with encoding="us-ascii".
When requested by setting the parameter " normalize-characters" on DOMSerializer to true, character normalization is performed according to the rules defined in [CharModel] on all data to be serialized, both markup and character data. The character normalization process affects only the data as it is being written; it does not alter the DOM's view of the document after serialization has completed.
When outputting unicode data, whether or not a byte order mark is serialized, or if the output is big-endian or little-endian, is implementation dependent.
Namespaces are fixed up during serialization, the serialization process will verify that namespace declarations, namespace prefixes and the namespace URI's associated with elements and attributes are consistent. If inconsistencies are found, the serialized form of the document will be altered to remove them. The method used for doing the namespace fixup while serializing a document is the algorithm defined in Appendix B.1, "Namespace normalization", of [DOM Level 3 Core] .
Any changes made affect only the namespace prefixes and declarations appearing in the serialized data. The DOM's view of the document is not altered by the serialization operation, and does not reflect any changes made to namespace declarations or prefixes in the serialized output. We may take back what we say in the above paragraph depending on feedback from implementors, but for now the belief is that the DOM's view of the document is not changed during serialization.
While serializing a document, the parameter "discard-default-content" controls whether or not non-specified data is serialized.
While serializing, errors are reported to the application through the error handler (DOMSerializer.config's " error-handler" parameter). This specification does in no way try to define all possible errors that can occur while serializing a DOM node, but some common error cases are defined. The types (DOMError.type) of errors and warnings defined by this specification are:

"invalid-data-in-cdata-section" [fatal]

Raised if the configuration parameter " split-cdata-sections" is set to false and invalid data is encountered in a CDATA section.

"unsupported-encoding" [fatal]

Raised if an unsupported encoding is encountered.

"unbound-namespace-in-entity" [warning]

Raised if the configuration parameter " entities" is set to true and an unbound namespace prefix is encounterd in a referenced entity.

"no-output-specified" [fatal]

Raised when writing to a DOMOutput if no output is specified in the DOMOutput.

In addition to raising the defined errors and warnings, implementations are expected to raise implementation specific errors and warnings for any other error and warning cases such as IO errors (file not found, permission denied,...) and so on.
See also the Document Object Model (DOM) Level 3 Load and Save Specification.
ru.kai.assistantschedule.core.xml.DOMSerializer

Examples of org.apache.ws.jaxme.util.DOMSerializer

    try {
      xw.setWriter(sw);
    } catch (JAXBException e) {
      throw new SAXException(e);
    }
    DOMSerializer ds = new DOMSerializer();
    ds.serialize(doc, xw);
    return sw.toString();
  }

View Full Code Here

Examples of org.apache.ws.jaxme.util.DOMSerializer

    try {
      xw.setWriter(sw);
    } catch (JAXBException e) {
      throw new SAXException(e);
    }
    DOMSerializer ds = new DOMSerializer();
    ds.serialize(doc, xw);
    return sw.toString();
  }

View Full Code Here

Examples of org.apache.ws.jaxme.util.DOMSerializer

    try {
      xw.setWriter(sw);
    } catch (JAXBException e) {
      throw new SAXException(e);
    }
    DOMSerializer ds = new DOMSerializer();
    ds.serialize(doc, xw);
    return sw.toString();
  }

View Full Code Here

Examples of org.apache.ws.jaxme.util.DOMSerializer

    return uh.getResult();
  }


  public Object unmarshal(Node pNode) throws JAXBException {
    UnmarshallerHandler uh = getUnmarshallerHandler();
    DOMSerializer ds = new DOMSerializer();
    try {
      ds.serialize(pNode, uh);
    } catch (SAXException e) {
      if (e.getException() != null) {
        throw new UnmarshalException(e.getException());
      } else {
        throw new UnmarshalException(e);

View Full Code Here

Examples of org.apache.xalan.serialize.DOMSerializer

            SanityManager.ASSERT(serializer != null,
                "Tried to serialize with uninitialized XML serializer.");
        }


        serializer.setWriter(sWriter);
        DOMSerializer dSer = serializer.asDOMSerializer();


        int sz = items.size();
        Object obj = null;


        /* Step 1: Empty sequence.  If we have an empty sequence then we
         * won't ever enter the for loop and the call to sWriter.toString()
         * at the end of this method will return an empty string, as
         * required.  Otherwise, for a non-empty sequence our "items"
         * list already corresponds to "S1".
         */


        // Iterate through the list and serialize each item.
        boolean lastItemWasString = false;
        for (int i = 0; i < sz; i++)
        {
            obj = items.get(i);
            // if it's a string, then this corresponds to some atomic
            // value, so just echo the string as it is.
            if (obj instanceof String)
            {
                /* Step 2: Atomic values.  If "obj" is a string then it
                 * corresponds to some atomic value whose "lexical
                 * representation" is obj.  So we just take that.
                 */


                if (lastItemWasString)
                {
                    /* Step 3: Adjacent strings.  If we have multiple adjacent
                     * strings then concatenate them with a single space
                     * between them.
                     */
                    sWriter.write(" ");
                }


                /* Step 4: Create a Text node from the adjacent strings.
                 * Since we're just going to serialize the Text node back
                 * into a string, we short-cut this step by skipping the
                 * creation of the Text node and just writing the string
                 * out directly to our serialized stream.
                 */
                sWriter.write((String)obj);
                lastItemWasString = true;
            }
            else if (obj instanceof Attr)
            {
                /* Step 7a: Attribute nodes.  If there is an Attribute node
                 * node in the sequence then we have to throw a serialization
                 * error.  NOTE: The rules say we also have to throw an error
                 * for Namespace nodes, but JAXP doesn't define a "Namespace"
                 * object per se; it just defines namespace prefixes and URIs
                 * on other Nodes.  So we just check for attributes.  If we
                 * find one then we take note of the fact that the result has
                 * a parentless attribute node and later, if the user calls
                 * XMLSERIALIZE on the received XMLDataValue we'll throw the
                 * error as required.  Note that we currently only get here
                 * for the XMLQUERY operator, which means we're serializing
                 * a result sequence returned from Xalan and we're going to
                 * store the serialized version into a Derby XML value.  In
                 * that case the serialization is an internal operation--and
                 * since the user didn't ask for it, we don't want to throw
                 * the serialization error here.  If we did, then whenever an
                 * XMLQUERY operation returned a result sequence with a top-
                 * level attribute in it, the user would see a serialization
                 * error. That's not correct since it is technically okay for
                 * the XMLQUERY operation to return a sequence with an attribute
                 * node; it's just not okay for a user to explicitly try to
                 * serialize that sequence. So instead of throwing the error
                 * here, we just take note of the fact that the sequence has
                 * a top-level attribute.  Then later, IF the user makes an
                 * explicit call to serialize the sequence, we'll throw the
                 * appropriate error (see XML.XMLSerialize()).
                 */
                if (xmlVal != null)
                    xmlVal.markAsHavingTopLevelAttr();
                dSer.serialize((Node)obj);
                lastItemWasString = false;
            }
            else
            { // We have a Node, so try to serialize it.
                Node n = (Node)obj;
                if (n instanceof Text)
                {
                    /* Step 6: Combine adjacent text nodes into a single
                     * text node.  Since we're just going to serialize the
                     * Text node back into a string, we short-cut this step
                     * by skipping the creation of a new Text node and just
                     * writing the text value out directly to our serialized
                     * stream.  Step 6 also says that empty text nodes should
                     * be dropped--but if the text node is empty, the call
                     * to getNodeValue() will return an empty string and
                     * thus we've effectively "dropped" the text node from
                     * the serialized result.  Note: it'd be cleaner to just
                     * call "serialize()" on the Text node like we do for
                     * all other Nodes, but Xalan doesn't allow that.  So
                     * use the getNodeValue() method instead.
                     */
                    sWriter.write(n.getNodeValue());
                }
                else
                {
                    /* Steps 5 and 7b: Copy all non-attribute, non-text
                     * nodes to the "normalized sequence" and then serialize
                     * that normalized sequence.  We short-cut this by
                     * just letting Xalan do the serialization for every
                     * Node in the current list of items that wasn't
                     * "serialized" as an atomic value, attribute, or
                     * text node.
                     */
                    dSer.serialize(n);
                }


                lastItemWasString = false;
            }
        }

View Full Code Here

Examples of org.apache.xalan.serialize.DOMSerializer

            SanityManager.ASSERT(serializer != null,
                "Tried to serialize with uninitialized XML serializer.");
        }


        serializer.setWriter(sWriter);
        DOMSerializer dSer = serializer.asDOMSerializer();


        int sz = items.size();
        Object obj = null;


        /* Step 1: Empty sequence.  If we have an empty sequence then we
         * won't ever enter the for loop and the call to sWriter.toString()
         * at the end of this method will return an empty string, as
         * required.  Otherwise, for a non-empty sequence our "items"
         * list already corresponds to "S1".
         */


        // Iterate through the list and serialize each item.
        boolean lastItemWasString = false;
        for (int i = 0; i < sz; i++)
        {
            obj = items.get(i);
            // if it's a string, then this corresponds to some atomic
            // value, so just echo the string as it is.
            if (obj instanceof String)
            {
                /* Step 2: Atomic values.  If "obj" is a string then it
                 * corresponds to some atomic value whose "lexical
                 * representation" is obj.  So we just take that.
                 */


                if (lastItemWasString)
                {
                    /* Step 3: Adjacent strings.  If we have multiple adjacent
                     * strings then concatenate them with a single space
                     * between them.
                     */
                    sWriter.write(" ");
                }


                /* Step 4: Create a Text node from the adjacent strings.
                 * Since we're just going to serialize the Text node back
                 * into a string, we short-cut this step by skipping the
                 * creation of the Text node and just writing the string
                 * out directly to our serialized stream.
                 */
                sWriter.write((String)obj);
                lastItemWasString = true;
            }
            else if (obj instanceof Attr)
            {
                /* Step 7a: Attribute nodes.  If there is an Attribute node
                 * node in the sequence then we have to throw a serialization
                 * error.  NOTE: The rules say we also have to throw an error
                 * for Namespace nodes, but JAXP doesn't define a "Namespace"
                 * object per se; it just defines namespace prefixes and URIs
                 * on other Nodes.  So we just check for attributes.  If we
                 * find one then we take note of the fact that the result has
                 * a parentless attribute node and later, if the user calls
                 * XMLSERIALIZE on the received XMLDataValue we'll throw the
                 * error as required.  Note that we currently only get here
                 * for the XMLQUERY operator, which means we're serializing
                 * a result sequence returned from Xalan and we're going to
                 * store the serialized version into a Derby XML value.  In
                 * that case the serialization is an internal operation--and
                 * since the user didn't ask for it, we don't want to throw
                 * the serialization error here.  If we did, then whenever an
                 * XMLQUERY operation returned a result sequence with a top-
                 * level attribute in it, the user would see a serialization
                 * error. That's not correct since it is technically okay for
                 * the XMLQUERY operation to return a sequence with an attribute
                 * node; it's just not okay for a user to explicitly try to
                 * serialize that sequence. So instead of throwing the error
                 * here, we just take note of the fact that the sequence has
                 * a top-level attribute.  Then later, IF the user makes an
                 * explicit call to serialize the sequence, we'll throw the
                 * appropriate error (see XML.XMLSerialize()).
                 */
                if (xmlVal != null)
                    xmlVal.markAsHavingTopLevelAttr();
                dSer.serialize((Node)obj);
                lastItemWasString = false;
            }
            else
            { // We have a Node, so try to serialize it.
                Node n = (Node)obj;
                if (n instanceof Text)
                {
                    /* Step 6: Combine adjacent text nodes into a single
                     * text node.  Since we're just going to serialize the
                     * Text node back into a string, we short-cut this step
                     * by skipping the creation of a new Text node and just
                     * writing the text value out directly to our serialized
                     * stream.  Step 6 also says that empty text nodes should
                     * be dropped--but if the text node is empty, the call
                     * to getNodeValue() will return an empty string and
                     * thus we've effectively "dropped" the text node from
                     * the serialized result.  Note: it'd be cleaner to just
                     * call "serialize()" on the Text node like we do for
                     * all other Nodes, but Xalan doesn't allow that.  So
                     * use the getNodeValue() method instead.
                     */
                    sWriter.write(n.getNodeValue());
                }
                else
                {
                    /* Steps 5 and 7b: Copy all non-attribute, non-text
                     * nodes to the "normalized sequence" and then serialize
                     * that normalized sequence.  We short-cut this by
                     * just letting Xalan do the serialization for every
                     * Node in the current list of items that wasn't
                     * "serialized" as an atomic value, attribute, or
                     * text node.
                     */
                    dSer.serialize(n);
                }


                lastItemWasString = false;
            }
        }

View Full Code Here

Examples of org.apache.xalan.serialize.DOMSerializer

            SanityManager.ASSERT(serializer != null,
                "Tried to serialize with uninitialized XML serializer.");
        }


        serializer.setWriter(sWriter);
        DOMSerializer dSer = serializer.asDOMSerializer();


        int sz = items.size();
        Object obj = null;


        /* Step 1: Empty sequence.  If we have an empty sequence then we
         * won't ever enter the for loop and the call to sWriter.toString()
         * at the end of this method will return an empty string, as
         * required.  Otherwise, for a non-empty sequence our "items"
         * list already corresponds to "S1".
         */


        // Iterate through the list and serialize each item.
        boolean lastItemWasString = false;
        for (int i = 0; i < sz; i++)
        {
            obj = items.get(i);
            // if it's a string, then this corresponds to some atomic
            // value, so just echo the string as it is.
            if (obj instanceof String)
            {
                /* Step 2: Atomic values.  If "obj" is a string then it
                 * corresponds to some atomic value whose "lexical
                 * representation" is obj.  So we just take that.
                 */


                if (lastItemWasString)
                {
                    /* Step 3: Adjacent strings.  If we have multiple adjacent
                     * strings then concatenate them with a single space
                     * between them.
                     */
                    sWriter.write(" ");
                }


                /* Step 4: Create a Text node from the adjacent strings.
                 * Since we're just going to serialize the Text node back
                 * into a string, we short-cut this step by skipping the
                 * creation of the Text node and just writing the string
                 * out directly to our serialized stream.
                 */
                sWriter.write((String)obj);
                lastItemWasString = true;
            }
            else if (obj instanceof Attr)
            {
                /* Step 7a: Attribute nodes.  If there is an Attribute node
                 * node in the sequence then we have to throw a serialization
                 * error.  NOTE: The rules say we also have to throw an error
                 * for Namespace nodes, but JAXP doesn't define a "Namespace"
                 * object per se; it just defines namespace prefixes and URIs
                 * on other Nodes.  So we just check for attributes.  If we
                 * find one then we take note of the fact that the result has
                 * a parentless attribute node and later, if the user calls
                 * XMLSERIALIZE on the received XMLDataValue we'll throw the
                 * error as required.  Note that we currently only get here
                 * for the XMLQUERY operator, which means we're serializing
                 * a result sequence returned from Xalan and we're going to
                 * store the serialized version into a Derby XML value.  In
                 * that case the serialization is an internal operation--and
                 * since the user didn't ask for it, we don't want to throw
                 * the serialization error here.  If we did, then whenever an
                 * XMLQUERY operation returned a result sequence with a top-
                 * level attribute in it, the user would see a serialization
                 * error. That's not correct since it is technically okay for
                 * the XMLQUERY operation to return a sequence with an attribute
                 * node; it's just not okay for a user to explicitly try to
                 * serialize that sequence. So instead of throwing the error
                 * here, we just take note of the fact that the sequence has
                 * a top-level attribute.  Then later, IF the user makes an
                 * explicit call to serialize the sequence, we'll throw the
                 * appropriate error (see XML.XMLSerialize()).
                 */
                if (xmlVal != null)
                    xmlVal.markAsHavingTopLevelAttr();
                dSer.serialize((Node)obj);
                lastItemWasString = false;
            }
            else
            { // We have a Node, so try to serialize it.
                Node n = (Node)obj;
                if (n instanceof Text)
                {
                    /* Step 6: Combine adjacent text nodes into a single
                     * text node.  Since we're just going to serialize the
                     * Text node back into a string, we short-cut this step
                     * by skipping the creation of a new Text node and just
                     * writing the text value out directly to our serialized
                     * stream.  Step 6 also says that empty text nodes should
                     * be dropped--but if the text node is empty, the call
                     * to getNodeValue() will return an empty string and
                     * thus we've effectively "dropped" the text node from
                     * the serialized result.  Note: it'd be cleaner to just
                     * call "serialize()" on the Text node like we do for
                     * all other Nodes, but Xalan doesn't allow that.  So
                     * use the getNodeValue() method instead.
                     */
                    sWriter.write(n.getNodeValue());
                }
                else
                {
                    /* Steps 5 and 7b: Copy all non-attribute, non-text
                     * nodes to the "normalized sequence" and then serialize
                     * that normalized sequence.  We short-cut this by
                     * just letting Xalan do the serialization for every
                     * Node in the current list of items that wasn't
                     * "serialized" as an atomic value, attribute, or
                     * text node.
                     */
                    dSer.serialize(n);
                }


                lastItemWasString = false;
            }
        }

View Full Code Here

Examples of org.apache.xalan.serialize.DOMSerializer

            SanityManager.ASSERT(serializer != null,
                "Tried to serialize with uninitialized XML serializer.");
        }


        serializer.setWriter(sWriter);
        DOMSerializer dSer = serializer.asDOMSerializer();


        int sz = items.size();
        Object obj = null;


        /* Step 1: Empty sequence.  If we have an empty sequence then we
         * won't ever enter the for loop and the call to sWriter.toString()
         * at the end of this method will return an empty string, as
         * required.  Otherwise, for a non-empty sequence our "items"
         * list already corresponds to "S1".
         */


        // Iterate through the list and serialize each item.
        boolean lastItemWasString = false;
        for (int i = 0; i < sz; i++)
        {
            obj = items.get(i);
            // if it's a string, then this corresponds to some atomic
            // value, so just echo the string as it is.
            if (obj instanceof String)
            {
                /* Step 2: Atomic values.  If "obj" is a string then it
                 * corresponds to some atomic value whose "lexical
                 * representation" is obj.  So we just take that.
                 */


                if (lastItemWasString)
                {
                    /* Step 3: Adjacent strings.  If we have multiple adjacent
                     * strings then concatenate them with a single space
                     * between them.
                     */
                    sWriter.write(" ");
                }


                /* Step 4: Create a Text node from the adjacent strings.
                 * Since we're just going to serialize the Text node back
                 * into a string, we short-cut this step by skipping the
                 * creation of the Text node and just writing the string
                 * out directly to our serialized stream.
                 */
                sWriter.write((String)obj);
                lastItemWasString = true;
            }
            else if (obj instanceof Attr)
            {
                /* Step 7a: Attribute nodes.  If there is an Attribute node
                 * node in the sequence then we have to throw a serialization
                 * error.  NOTE: The rules say we also have to throw an error
                 * for Namespace nodes, but JAXP doesn't define a "Namespace"
                 * object per se; it just defines namespace prefixes and URIs
                 * on other Nodes.  So we just check for attributes.  If we
                 * find one then we take note of the fact that the result has
                 * a parentless attribute node and later, if the user calls
                 * XMLSERIALIZE on the received XMLDataValue we'll throw the
                 * error as required.  Note that we currently only get here
                 * for the XMLQUERY operator, which means we're serializing
                 * a result sequence returned from Xalan and we're going to
                 * store the serialized version into a Derby XML value.  In
                 * that case the serialization is an internal operation--and
                 * since the user didn't ask for it, we don't want to throw
                 * the serialization error here.  If we did, then whenever an
                 * XMLQUERY operation returned a result sequence with a top-
                 * level attribute in it, the user would see a serialization
                 * error. That's not correct since it is technically okay for
                 * the XMLQUERY operation to return a sequence with an attribute
                 * node; it's just not okay for a user to explicitly try to
                 * serialize that sequence. So instead of throwing the error
                 * here, we just take note of the fact that the sequence has
                 * a top-level attribute.  Then later, IF the user makes an
                 * explicit call to serialize the sequence, we'll throw the
                 * appropriate error (see XML.XMLSerialize()).
                 */
                if (xmlVal != null)
                    xmlVal.markAsHavingTopLevelAttr();
                dSer.serialize((Node)obj);
                lastItemWasString = false;
            }
            else
            { // We have a Node, so try to serialize it.
                Node n = (Node)obj;
                if (n instanceof Text)
                {
                    /* Step 6: Combine adjacent text nodes into a single
                     * text node.  Since we're just going to serialize the
                     * Text node back into a string, we short-cut this step
                     * by skipping the creation of a new Text node and just
                     * writing the text value out directly to our serialized
                     * stream.  Step 6 also says that empty text nodes should
                     * be dropped--but if the text node is empty, the call
                     * to getNodeValue() will return an empty string and
                     * thus we've effectively "dropped" the text node from
                     * the serialized result.  Note: it'd be cleaner to just
                     * call "serialize()" on the Text node like we do for
                     * all other Nodes, but Xalan doesn't allow that.  So
                     * use the getNodeValue() method instead.
                     */
                    sWriter.write(n.getNodeValue());
                }
                else
                {
                    /* Steps 5 and 7b: Copy all non-attribute, non-text
                     * nodes to the "normalized sequence" and then serialize
                     * that normalized sequence.  We short-cut this by
                     * just letting Xalan do the serialization for every
                     * Node in the current list of items that wasn't
                     * "serialized" as an atomic value, attribute, or
                     * text node.
                     */
                    dSer.serialize(n);
                }


                lastItemWasString = false;
            }
        }

View Full Code Here

Examples of org.apache.xml.serialize.DOMSerializer

      outputOptions.setIndent( 4 );
      outputOptions.setMethod( "xml" );
      //if (System.getProperty("os.name").startsWith("Windows")) {
      outputOptions.setEncoding("ISO-8859-1");
      Writer writer = new BufferedWriter(new FileWriter(new File(filename)));
      DOMSerializer serializer = new XMLSerializer( writer,outputOptions );
      serializer.serialize( document );
      writer.close();
  }

View Full Code Here

Examples of org.apache.xml.serialize.DOMSerializer

        OutputFormat of = new OutputFormat();
        of.setIndenting(true);
        of.setMethod(Method.XML);
        of.setOmitDocumentType(true);
        of.setOmitXMLDeclaration(true);
        DOMSerializer serializer = new XMLSerializer(System.out, of);
        try {
            serializer.serialize(element);
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }

View Full Code Here

0 1 2 3 4

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.