Back to index...

	/*
	* reserved comment block
	* DO NOT REMOVE OR ALTER!
	*/
	/*
	* 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.dom3;

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.io.StringWriter;
	import java.io.UnsupportedEncodingException;
	import java.io.Writer;
	import java.net.HttpURLConnection;
	import java.net.URL;
	import java.net.URLConnection;
	import java.util.Properties;

	import com.sun.org.apache.xml.internal.serializer.DOM3Serializer;
	import com.sun.org.apache.xml.internal.serializer.Encodings;
	import com.sun.org.apache.xml.internal.serializer.Serializer;
	import com.sun.org.apache.xml.internal.serializer.ToXMLStream;
	import com.sun.org.apache.xml.internal.serializer.OutputPropertiesFactory;
	import com.sun.org.apache.xml.internal.serializer.SerializerFactory;
	import com.sun.org.apache.xml.internal.serializer.utils.MsgKey;
	import com.sun.org.apache.xml.internal.serializer.utils.Utils;
	import com.sun.org.apache.xml.internal.serializer.utils.SystemIDResolver;
	import org.w3c.dom.DOMConfiguration;
	import org.w3c.dom.DOMError;
	import org.w3c.dom.DOMErrorHandler;
	import org.w3c.dom.DOMException;
	import org.w3c.dom.DOMStringList;
	import org.w3c.dom.Document;
	import org.w3c.dom.Node;
	import org.w3c.dom.ls.LSException;
	import org.w3c.dom.ls.LSOutput;
	import org.w3c.dom.ls.LSSerializer;
	import org.w3c.dom.ls.LSSerializerFilter;


	/**
	* Implemenatation of DOM Level 3 org.w3c.ls.LSSerializer and
	* org.w3c.dom.ls.DOMConfiguration. Serialization is achieved by delegating
	* serialization calls to <CODE>org.apache.xml.serializer.ToStream</CODE> or
	* one of its derived classes depending on the serialization method, while walking
	* the DOM in DOM3TreeWalker.
	* @see <a href="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save.html#LS-LSSerializer">org.w3c.dom.ls.LSSerializer</a>
	* @see <a href="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#DOMConfiguration">org.w3c.dom.DOMConfiguration</a>
	*
	* @version $Id:
	*
	* @xsl.usage internal
	*/
	final public class LSSerializerImpl implements DOMConfiguration, LSSerializer {

	/** private data members */
	private Serializer fXMLSerializer = null;

	// Tracks DOMConfiguration features.
	protected int fFeatures = 0;

	// Common DOM serializer
	private DOM3Serializer fDOMSerializer = null;

	// A filter set on the LSSerializer
	private LSSerializerFilter fSerializerFilter = null;

	// Stores the nodeArg parameter to speed up multiple writes of the same node.
	private Node fVisitedNode = null;

	// The end-of-line character sequence used in serialization. "\n" is whats used on the web.
	private String fEndOfLine = "\n";

	// The DOMErrorhandler.
	private DOMErrorHandler fDOMErrorHandler = null;

	// The Configuration parameter to pass to the Underlying serilaizer.
	private Properties fDOMConfigProperties = null;

	// The encoding to use during serialization.
	private String fEncoding;

	// ************************************************************************
	// DOM Level 3 DOM Configuration parameter names
	// ************************************************************************
	// Parameter canonical-form, true [optional] - NOT SUPPORTED
	private final static int CANONICAL = 0x1 << 0;

	// Parameter cdata-sections, true [required] (default)
	private final static int CDATA = 0x1 << 1;

	// Parameter check-character-normalization, true [optional] - NOT SUPPORTED
	private final static int CHARNORMALIZE = 0x1 << 2;

	// Parameter comments, true [required] (default)
	private final static int COMMENTS = 0x1 << 3;

	// Parameter datatype-normalization, true [optional] - NOT SUPPORTED
	private final static int DTNORMALIZE = 0x1 << 4;

	// Parameter element-content-whitespace, true [required] (default) - value - false [optional] NOT SUPPORTED
	private final static int ELEM_CONTENT_WHITESPACE = 0x1 << 5;

	// Parameter entities, true [required] (default)
	private final static int ENTITIES = 0x1 << 6;

	// Parameter infoset, true [required] (default), false has no effect --> True has no effect for the serializer
	private final static int INFOSET = 0x1 << 7;

	// Parameter namespaces, true [required] (default)
	private final static int NAMESPACES = 0x1 << 8;

	// Parameter namespace-declarations, true [required] (default)
	private final static int NAMESPACEDECLS = 0x1 << 9;

	// Parameter normalize-characters, true [optional] - NOT SUPPORTED
	private final static int NORMALIZECHARS = 0x1 << 10;

	// Parameter split-cdata-sections, true [required] (default)
	private final static int SPLITCDATA = 0x1 << 11;

	// Parameter validate, true [optional] - NOT SUPPORTED
	private final static int VALIDATE = 0x1 << 12;

	// Parameter validate-if-schema, true [optional] - NOT SUPPORTED
	private final static int SCHEMAVALIDATE = 0x1 << 13;

	// Parameter split-cdata-sections, true [required] (default)
	private final static int WELLFORMED = 0x1 << 14;

	// Parameter discard-default-content, true [required] (default)
	// Not sure how this will be used in level 2 Documents
	private final static int DISCARDDEFAULT = 0x1 << 15;

	// Parameter format-pretty-print, true [optional]
	private final static int PRETTY_PRINT = 0x1 << 16;

	// Parameter ignore-unknown-character-denormalizations, true [required] (default)
	// We currently do not support XML 1.1 character normalization
	private final static int IGNORE_CHAR_DENORMALIZE = 0x1 << 17;

	// Parameter discard-default-content, true [required] (default)
	private final static int XMLDECL = 0x1 << 18;
	// ************************************************************************

	// Recognized parameters for which atleast one value can be set
	private String fRecognizedParameters [] = {
	DOMConstants.DOM_CANONICAL_FORM,
	DOMConstants.DOM_CDATA_SECTIONS,
	DOMConstants.DOM_CHECK_CHAR_NORMALIZATION,
	DOMConstants.DOM_COMMENTS,
	DOMConstants.DOM_DATATYPE_NORMALIZATION,
	DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE,
	DOMConstants.DOM_ENTITIES,
	DOMConstants.DOM_INFOSET,
	DOMConstants.DOM_NAMESPACES,
	DOMConstants.DOM_NAMESPACE_DECLARATIONS,
	//DOMConstants.DOM_NORMALIZE_CHARACTERS,
	DOMConstants.DOM_SPLIT_CDATA,
	DOMConstants.DOM_VALIDATE,
	DOMConstants.DOM_VALIDATE_IF_SCHEMA,
	DOMConstants.DOM_WELLFORMED,
	DOMConstants.DOM_DISCARD_DEFAULT_CONTENT,
	DOMConstants.DOM_FORMAT_PRETTY_PRINT,
	DOMConstants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS,
	DOMConstants.DOM_XMLDECL,
	DOMConstants.DOM_ERROR_HANDLER
	};


	/**
	* Constructor: Creates a LSSerializerImpl object. The underlying
	* XML 1.0 or XML 1.1 org.apache.xml.serializer.Serializer object is
	* created and initialized the first time any of the write methods are
	* invoked to serialize the Node. Subsequent write methods on the same
	* LSSerializerImpl object will use the previously created Serializer object.
	*/
	public LSSerializerImpl () {
	// set default parameters
	fFeatures \|= CDATA;
	fFeatures \|= COMMENTS;
	fFeatures \|= ELEM_CONTENT_WHITESPACE;
	fFeatures \|= ENTITIES;
	fFeatures \|= NAMESPACES;
	fFeatures \|= NAMESPACEDECLS;
	fFeatures \|= SPLITCDATA;
	fFeatures \|= WELLFORMED;
	fFeatures \|= DISCARDDEFAULT;
	fFeatures \|= XMLDECL;

	// New OutputFormat properties
	fDOMConfigProperties = new Properties();

	// Initialize properties to be passed on the underlying serializer
	initializeSerializerProps();

	// Read output_xml.properties and System Properties to initialize properties
	Properties configProps = OutputPropertiesFactory.getDefaultMethodProperties("xml");

	// change xml version from 1.0 to 1.1
	//configProps.setProperty("version", "1.1");

	// Get a serializer that seriailizes according to the properties,
	// which in this case is to xml
	fXMLSerializer = new ToXMLStream();
	fXMLSerializer.setOutputFormat(configProps);

	// Initialize Serializer
	fXMLSerializer.setOutputFormat(fDOMConfigProperties);
	}

	/**
	* Initializes the underlying serializer's configuration depending on the
	* default DOMConfiguration parameters. This method must be called before a
	* node is to be serialized.
	*
	* @xsl.usage internal
	*/
	public void initializeSerializerProps () {
	// canonical-form
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CANONICAL_FORM, DOMConstants.DOM3_DEFAULT_FALSE);

	// cdata-sections
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CDATA_SECTIONS, DOMConstants.DOM3_DEFAULT_TRUE);

	// "check-character-normalization"
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CHECK_CHAR_NORMALIZATION,
	DOMConstants.DOM3_DEFAULT_FALSE);

	// comments
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_COMMENTS, DOMConstants.DOM3_DEFAULT_TRUE);

	// datatype-normalization
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DATATYPE_NORMALIZATION,
	DOMConstants.DOM3_DEFAULT_FALSE);

	// element-content-whitespace
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE,
	DOMConstants.DOM3_DEFAULT_TRUE);

	// entities
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ENTITIES, DOMConstants.DOM3_DEFAULT_TRUE);

	// error-handler
	// Should we set our default ErrorHandler
	/*
	* if (fDOMConfig.getParameter(Constants.DOM_ERROR_HANDLER) != null) {
	* fDOMErrorHandler =
	* (DOMErrorHandler)fDOMConfig.getParameter(Constants.DOM_ERROR_HANDLER); }
	*/

	// infoset
	if ((fFeatures & INFOSET) != 0) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACES, DOMConstants.DOM3_DEFAULT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACE_DECLARATIONS,
	DOMConstants.DOM3_DEFAULT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_COMMENTS, DOMConstants.DOM3_DEFAULT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE,
	DOMConstants.DOM3_DEFAULT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_WELLFORMED, DOMConstants.DOM3_DEFAULT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ENTITIES, DOMConstants.DOM3_DEFAULT_FALSE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CDATA_SECTIONS,
	DOMConstants.DOM3_DEFAULT_FALSE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_VALIDATE_IF_SCHEMA,
	DOMConstants.DOM3_DEFAULT_FALSE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DATATYPE_NORMALIZATION,
	DOMConstants.DOM3_DEFAULT_FALSE);
	}

	// namespaces
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACES, DOMConstants.DOM3_DEFAULT_TRUE);

	// namespace-declarations
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACE_DECLARATIONS,
	DOMConstants.DOM3_DEFAULT_TRUE);

	// normalize-characters
	/*
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NORMALIZE_CHARACTERS,
	DOMConstants.DOM3_DEFAULT_FALSE);
	*/

	// split-cdata-sections
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_SPLIT_CDATA, DOMConstants.DOM3_DEFAULT_TRUE);

	// validate
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_VALIDATE, DOMConstants.DOM3_DEFAULT_FALSE);

	// validate-if-schema
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_VALIDATE_IF_SCHEMA,
	DOMConstants.DOM3_DEFAULT_FALSE);

	// well-formed
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_WELLFORMED, DOMConstants.DOM3_DEFAULT_TRUE);

	// pretty-print
	fDOMConfigProperties.setProperty(
	DOMConstants.S_XSL_OUTPUT_INDENT,
	DOMConstants.DOM3_DEFAULT_FALSE);
	fDOMConfigProperties.setProperty(
	OutputPropertiesFactory.S_KEY_INDENT_AMOUNT, Integer.toString(4));

	//

	// discard-default-content
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DISCARD_DEFAULT_CONTENT,
	DOMConstants.DOM3_DEFAULT_TRUE);

	// xml-declaration
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL, "no");

	}

	// ************************************************************************
	// DOMConfiguraiton implementation
	// ************************************************************************

	/**
	* Checks if setting a parameter to a specific value is supported.
	*
	* @see org.w3c.dom.DOMConfiguration#canSetParameter(java.lang.String, java.lang.Object)
	* @since DOM Level 3
	* @param name A String containing the DOMConfiguration parameter name.
	* @param value An Object specifying the value of the corresponding parameter.
	*/
	public boolean canSetParameter(String name, Object value) {
	if (value instanceof Boolean){
	if ( name.equalsIgnoreCase(DOMConstants.DOM_CDATA_SECTIONS)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_COMMENTS)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_ENTITIES)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_INFOSET)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_NAMESPACES)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_NAMESPACE_DECLARATIONS)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_SPLIT_CDATA)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_WELLFORMED)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_DISCARD_DEFAULT_CONTENT)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_FORMAT_PRETTY_PRINT)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_XMLDECL)){
	// both values supported
	return true;
	}
	else if (name.equalsIgnoreCase(DOMConstants.DOM_CANONICAL_FORM)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_CHECK_CHAR_NORMALIZATION)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_DATATYPE_NORMALIZATION)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE_IF_SCHEMA)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE)
	// \|\| name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)
	) {
	// true is not supported
	return !((Boolean)value).booleanValue();
	}
	else if (name.equalsIgnoreCase(DOMConstants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {
	// false is not supported
	return ((Boolean)value).booleanValue();
	}
	}
	else if (name.equalsIgnoreCase(DOMConstants.DOM_ERROR_HANDLER) &&
	value == null \|\| value instanceof DOMErrorHandler){
	return true;
	}
	return false;
	}
	/**
	* This method returns the value of a parameter if known.
	*
	* @see org.w3c.dom.DOMConfiguration#getParameter(java.lang.String)
	*
	* @param name A String containing the DOMConfiguration parameter name
	* whose value is to be returned.
	* @return Object The value of the parameter if known.
	*/
	public Object getParameter(String name) throws DOMException {

	if(name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)){
	return null;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_COMMENTS)) {
	return ((fFeatures & COMMENTS) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_CDATA_SECTIONS)) {
	return ((fFeatures & CDATA) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_ENTITIES)) {
	return ((fFeatures & ENTITIES) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_NAMESPACES)) {
	return ((fFeatures & NAMESPACES) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_NAMESPACE_DECLARATIONS)) {
	return ((fFeatures & NAMESPACEDECLS) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_SPLIT_CDATA)) {
	return ((fFeatures & SPLITCDATA) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_WELLFORMED)) {
	return ((fFeatures & WELLFORMED) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_DISCARD_DEFAULT_CONTENT)) {
	return ((fFeatures & DISCARDDEFAULT) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_FORMAT_PRETTY_PRINT)) {
	return ((fFeatures & PRETTY_PRINT) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_XMLDECL)) {
	return ((fFeatures & XMLDECL) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE)) {
	return ((fFeatures & ELEM_CONTENT_WHITESPACE) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {
	return Boolean.TRUE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_CANONICAL_FORM)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_CHECK_CHAR_NORMALIZATION)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_DATATYPE_NORMALIZATION)
	// \|\| name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE_IF_SCHEMA)) {
	return Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_INFOSET)){
	if ((fFeatures & ENTITIES) == 0 &&
	(fFeatures & CDATA) == 0 &&
	(fFeatures & ELEM_CONTENT_WHITESPACE) != 0 &&
	(fFeatures & NAMESPACES) != 0 &&
	(fFeatures & NAMESPACEDECLS) != 0 &&
	(fFeatures & WELLFORMED) != 0 &&
	(fFeatures & COMMENTS) != 0) {
	return Boolean.TRUE;
	}
	return Boolean.FALSE;
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_ERROR_HANDLER)) {
	return fDOMErrorHandler;
	} else if (
	name.equalsIgnoreCase(DOMConstants.DOM_SCHEMA_LOCATION)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_SCHEMA_TYPE)) {
	return null;
	} else {
	// Here we have to add the Xalan specific DOM Message Formatter
	String msg = Utils.messages.createMessage(
	MsgKey.ER_FEATURE_NOT_FOUND,
	new Object[] { name });
	throw new DOMException(DOMException.NOT_FOUND_ERR, msg);
	}
	}

	/**
	* This method returns a of the parameters supported by this DOMConfiguration object
	* and for which at least one value can be set by the application
	*
	* @see org.w3c.dom.DOMConfiguration#getParameterNames()
	*
	* @return DOMStringList A list of DOMConfiguration parameters recognized
	* by the serializer
	*/
	public DOMStringList getParameterNames() {
	return new DOMStringListImpl(fRecognizedParameters);
	}

	/**
	* This method sets the value of the named parameter.
	*
	* @see org.w3c.dom.DOMConfiguration#setParameter(java.lang.String, java.lang.Object)
	*
	* @param name A String containing the DOMConfiguration parameter name.
	* @param value An Object contaiing the parameters value to set.
	*/
	public void setParameter(String name, Object value) throws DOMException {
	// If the value is a boolean
	if (value instanceof Boolean) {
	boolean state = ((Boolean) value).booleanValue();

	if (name.equalsIgnoreCase(DOMConstants.DOM_COMMENTS)) {
	fFeatures = state ? fFeatures \| COMMENTS : fFeatures
	& ~COMMENTS;
	// comments
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_COMMENTS, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_COMMENTS, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_CDATA_SECTIONS)) {
	fFeatures = state ? fFeatures \| CDATA : fFeatures
	& ~CDATA;
	// cdata-sections
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CDATA_SECTIONS, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CDATA_SECTIONS, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_ENTITIES)) {
	fFeatures = state ? fFeatures \| ENTITIES : fFeatures
	& ~ENTITIES;
	// entities
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ENTITIES, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ENTITIES, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_NAMESPACES)) {
	fFeatures = state ? fFeatures \| NAMESPACES : fFeatures
	& ~NAMESPACES;
	// namespaces
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACES, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACES, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name
	.equalsIgnoreCase(DOMConstants.DOM_NAMESPACE_DECLARATIONS)) {
	fFeatures = state ? fFeatures \| NAMESPACEDECLS
	: fFeatures & ~NAMESPACEDECLS;
	// namespace-declarations
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACE_DECLARATIONS, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACE_DECLARATIONS, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_SPLIT_CDATA)) {
	fFeatures = state ? fFeatures \| SPLITCDATA : fFeatures
	& ~SPLITCDATA;
	// split-cdata-sections
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_SPLIT_CDATA, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_SPLIT_CDATA, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_WELLFORMED)) {
	fFeatures = state ? fFeatures \| WELLFORMED : fFeatures
	& ~WELLFORMED;
	// well-formed
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_WELLFORMED, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_WELLFORMED, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name
	.equalsIgnoreCase(DOMConstants.DOM_DISCARD_DEFAULT_CONTENT)) {
	fFeatures = state ? fFeatures \| DISCARDDEFAULT
	: fFeatures & ~DISCARDDEFAULT;
	// discard-default-content
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DISCARD_DEFAULT_CONTENT, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DISCARD_DEFAULT_CONTENT, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_FORMAT_PRETTY_PRINT)) {
	fFeatures = state ? fFeatures \| PRETTY_PRINT : fFeatures
	& ~PRETTY_PRINT;
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_INDENT,DOMConstants.DOM3_EXPLICIT_TRUE);
	fDOMConfigProperties.setProperty(OutputPropertiesFactory.S_KEY_INDENT_AMOUNT, Integer.toString(4));
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_INDENT,DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_XMLDECL)) {
	fFeatures = state ? fFeatures \| XMLDECL : fFeatures
	& ~XMLDECL;
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL, "no");
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL, "yes");
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE)) {
	fFeatures = state ? fFeatures \| ELEM_CONTENT_WHITESPACE : fFeatures
	& ~ELEM_CONTENT_WHITESPACE;
	// element-content-whitespace
	if (state) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE, DOMConstants.DOM3_EXPLICIT_TRUE);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {
	// false is not supported
	if (!state) {
	// Here we have to add the Xalan specific DOM Message Formatter
	String msg = Utils.messages.createMessage(
	MsgKey.ER_FEATURE_NOT_SUPPORTED,
	new Object[] { name });
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	} else {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS, DOMConstants.DOM3_EXPLICIT_TRUE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_CANONICAL_FORM)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE_IF_SCHEMA)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_CHECK_CHAR_NORMALIZATION)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_DATATYPE_NORMALIZATION)
	// \|\| name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)
	) {
	// true is not supported
	if (state) {
	String msg = Utils.messages.createMessage(
	MsgKey.ER_FEATURE_NOT_SUPPORTED,
	new Object[] { name });
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	} else {
	if (name.equalsIgnoreCase(DOMConstants.DOM_CANONICAL_FORM)) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CANONICAL_FORM, DOMConstants.DOM3_EXPLICIT_FALSE);
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE_IF_SCHEMA)) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_VALIDATE_IF_SCHEMA, DOMConstants.DOM3_EXPLICIT_FALSE);
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE)) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_VALIDATE, DOMConstants.DOM3_EXPLICIT_FALSE);
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_VALIDATE_IF_SCHEMA)) {
	fDOMConfigProperties.setProperty(DOMConstants.DOM_CHECK_CHAR_NORMALIZATION
	+ DOMConstants.DOM_CHECK_CHAR_NORMALIZATION, DOMConstants.DOM3_EXPLICIT_FALSE);
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_DATATYPE_NORMALIZATION)) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DATATYPE_NORMALIZATION, DOMConstants.DOM3_EXPLICIT_FALSE);
	} /* else if (name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)) {
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NORMALIZE_CHARACTERS, DOMConstants.DOM3_EXPLICIT_FALSE);
	} */
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_INFOSET)) {
	if (state) {
	fFeatures &= ~ENTITIES;
	fFeatures &= ~CDATA;
	fFeatures &= ~SCHEMAVALIDATE;
	fFeatures &= ~DTNORMALIZE;
	fFeatures \|= NAMESPACES;
	fFeatures \|= NAMESPACEDECLS;
	fFeatures \|= WELLFORMED;
	fFeatures \|= ELEM_CONTENT_WHITESPACE;
	fFeatures \|= COMMENTS;

	// infoset
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACES, DOMConstants.DOM3_EXPLICIT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_NAMESPACE_DECLARATIONS, DOMConstants.DOM3_EXPLICIT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_COMMENTS, DOMConstants.DOM3_EXPLICIT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE, DOMConstants.DOM3_EXPLICIT_TRUE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_WELLFORMED, DOMConstants.DOM3_EXPLICIT_TRUE);

	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_ENTITIES, DOMConstants.DOM3_EXPLICIT_FALSE);

	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_CDATA_SECTIONS, DOMConstants.DOM3_EXPLICIT_FALSE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_VALIDATE_IF_SCHEMA, DOMConstants.DOM3_EXPLICIT_FALSE);
	fDOMConfigProperties.setProperty(DOMConstants.S_DOM3_PROPERTIES_NS
	+ DOMConstants.DOM_DATATYPE_NORMALIZATION, DOMConstants.DOM3_EXPLICIT_FALSE);
	}
	} else if (name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)) {
	String msg = Utils.messages.createMessage(
	MsgKey.ER_FEATURE_NOT_SUPPORTED,
	new Object[] { name });
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	} else {
	// Setting this to false has no effect
	}
	} // If the parameter value is not a boolean
	else if (name.equalsIgnoreCase(DOMConstants.DOM_ERROR_HANDLER)) {
	if (value == null \|\| value instanceof DOMErrorHandler) {
	fDOMErrorHandler = (DOMErrorHandler)value;
	} else {
	String msg = Utils.messages.createMessage(
	MsgKey.ER_TYPE_MISMATCH_ERR,
	new Object[] { name });
	throw new DOMException(DOMException.TYPE_MISMATCH_ERR, msg);
	}
	} else if (
	name.equalsIgnoreCase(DOMConstants.DOM_SCHEMA_LOCATION)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_SCHEMA_TYPE)
	\|\| name.equalsIgnoreCase(DOMConstants.DOM_NORMALIZE_CHARACTERS)
	&& value != null) {
	String msg = Utils.messages.createMessage(
	MsgKey.ER_FEATURE_NOT_SUPPORTED,
	new Object[] { name });
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	} else {
	String msg = Utils.messages.createMessage(
	MsgKey.ER_FEATURE_NOT_FOUND,
	new Object[] { name });
	throw new DOMException(DOMException.NOT_FOUND_ERR, msg);
	}
	}
	// ************************************************************************


	// ************************************************************************
	// DOMConfiguraiton implementation
	// ************************************************************************

	/**
	* Returns the DOMConfiguration of the LSSerializer.
	*
	* @see org.w3c.dom.ls.LSSerializer#getDomConfig()
	* @since DOM Level 3
	* @return A DOMConfiguration object.
	*/
	public DOMConfiguration getDomConfig() {
	return (DOMConfiguration)this;
	}

	/**
	* Returns the DOMConfiguration of the LSSerializer.
	*
	* @see org.w3c.dom.ls.LSSerializer#getFilter()
	* @since DOM Level 3
	* @return A LSSerializerFilter object.
	*/
	public LSSerializerFilter getFilter() {
	return fSerializerFilter;
	}

	/**
	* Returns the End-Of-Line sequence of characters to be used in the XML
	* being serialized. If none is set a default "\n" is returned.
	*
	* @see org.w3c.dom.ls.LSSerializer#getNewLine()
	* @since DOM Level 3
	* @return A String containing the end-of-line character sequence used in
	* serialization.
	*/
	public String getNewLine() {
	return fEndOfLine;
	}

	/**
	* Set a LSSerilizerFilter on the LSSerializer. When set, the filter is
	* called before each node is serialized which depending on its implemention
	* determines if the node is to be serialized or not.
	*
	* @see org.w3c.dom.ls.LSSerializer#setFilter
	* @since DOM Level 3
	* @param filter A LSSerializerFilter to be applied to the stream to serialize.
	*/
	public void setFilter(LSSerializerFilter filter) {
	fSerializerFilter = filter;
	}

	/**
	* Sets the End-Of-Line sequence of characters to be used in the XML
	* being serialized. Setting this attribute to null will reset its
	* value to the default value i.e. "\n".
	*
	* @see org.w3c.dom.ls.LSSerializer#setNewLine
	* @since DOM Level 3
	* @param newLine a String that is the end-of-line character sequence to be used in
	* serialization.
	*/
	public void setNewLine(String newLine) {
	fEndOfLine = newLine !=null? newLine: fEndOfLine;
	}

	/**
	* Serializes the specified node to the specified LSOutput and returns true if the Node
	* was successfully serialized.
	*
	* @see org.w3c.dom.ls.LSSerializer#write(org.w3c.dom.Node, org.w3c.dom.ls.LSOutput)
	* @since DOM Level 3
	* @param nodeArg The Node to serialize.
	* @throws org.w3c.dom.ls.LSException SERIALIZE_ERR: Raised if the
	* LSSerializer was unable to serialize the node.
	*
	*/
	public boolean write(Node nodeArg, LSOutput destination) throws LSException {
	// If the destination is null
	if (destination == null) {
	String msg = Utils.messages
	.createMessage(
	MsgKey.ER_NO_OUTPUT_SPECIFIED,
	null);
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, msg,
	MsgKey.ER_NO_OUTPUT_SPECIFIED));
	}
	throw new LSException(LSException.SERIALIZE_ERR, msg);
	}

	// If nodeArg is null, return false. Should we throw and LSException instead?
	if (nodeArg == null ) {
	return false;
	}

	// Obtain a reference to the serializer to use
	// Serializer serializer = getXMLSerializer(xmlVersion);
	Serializer serializer = fXMLSerializer;
	serializer.reset();

	// If the node has not been seen
	if ( nodeArg != fVisitedNode) {
	// Determine the XML Document version of the Node
	String xmlVersion = getXMLVersion(nodeArg);

	// Determine the encoding: 1.LSOutput.encoding, 2.Document.inputEncoding, 3.Document.xmlEncoding.
	fEncoding = destination.getEncoding();
	if (fEncoding == null ) {
	fEncoding = getInputEncoding(nodeArg);
	fEncoding = fEncoding != null ? fEncoding : getXMLEncoding(nodeArg) == null? "UTF-8": getXMLEncoding(nodeArg);
	}

	// If the encoding is not recognized throw an exception.
	// Note: The serializer defaults to UTF-8 when created
	if (!Encodings.isRecognizedEncoding(fEncoding)) {
	String msg = Utils.messages
	.createMessage(
	MsgKey.ER_UNSUPPORTED_ENCODING,
	null);
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, msg,
	MsgKey.ER_UNSUPPORTED_ENCODING));
	}
	throw new LSException(LSException.SERIALIZE_ERR, msg);
	}

	serializer.getOutputFormat().setProperty("version", xmlVersion);

	// Set the output encoding and xml version properties
	fDOMConfigProperties.setProperty(DOMConstants.S_XERCES_PROPERTIES_NS + DOMConstants.S_XML_VERSION, xmlVersion);
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_ENCODING, fEncoding);

	// If the node to be serialized is not a Document, Element, or Entity
	// node
	// then the XML declaration, or text declaration, should be never be
	// serialized.
	if ( (nodeArg.getNodeType() != Node.DOCUMENT_NODE
	\|\| nodeArg.getNodeType() != Node.ELEMENT_NODE
	\|\| nodeArg.getNodeType() != Node.ENTITY_NODE)
	&& ((fFeatures & XMLDECL) != 0)) {
	fDOMConfigProperties.setProperty(
	DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL,
	DOMConstants.DOM3_DEFAULT_FALSE);
	}

	fVisitedNode = nodeArg;
	}

	// Update the serializer properties
	fXMLSerializer.setOutputFormat(fDOMConfigProperties);

	//
	try {

	// The LSSerializer will use the LSOutput object to determine
	// where to serialize the output to in the following order the
	// first one that is not null and not an empty string will be
	// used: 1.LSOutput.characterStream, 2.LSOutput.byteStream,
	// 3. LSOutput.systemId
	// 1.LSOutput.characterStream
	Writer writer = destination.getCharacterStream();
	if (writer == null ) {

	// 2.LSOutput.byteStream
	OutputStream outputStream = destination.getByteStream();
	if ( outputStream == null) {

	// 3. LSOutput.systemId
	String uri = destination.getSystemId();
	if (uri == null) {
	String msg = Utils.messages
	.createMessage(
	MsgKey.ER_NO_OUTPUT_SPECIFIED,
	null);
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, msg,
	MsgKey.ER_NO_OUTPUT_SPECIFIED));
	}
	throw new LSException(LSException.SERIALIZE_ERR, msg);

	} else {
	// Expand the System Id and obtain an absolute URI for it.
	String absoluteURI = SystemIDResolver.getAbsoluteURI(uri);

	URL url = new URL(absoluteURI);
	OutputStream urlOutStream = null;
	String protocol = url.getProtocol();
	String host = url.getHost();

	// For file protocols, there is no need to use a URL to get its
	// corresponding OutputStream

	// Scheme names consist of a sequence of characters. The lower case
	// letters "a"--"z", digits, and the characters plus ("+"), period
	// ("."), and hyphen ("-") are allowed. For resiliency, programs
	// interpreting URLs should treat upper case letters as equivalent to
	// lower case in scheme names (e.g., allow "HTTP" as well as "http").
	if (protocol.equalsIgnoreCase("file")
	&& (host == null \|\| host.length() == 0 \|\| host.equals("localhost"))) {
	// do we also need to check for host.equals(hostname)
	urlOutStream = new FileOutputStream(new File(url.getPath()));

	} else {
	// This should support URL's whose schemes are mentioned in
	// RFC1738 other than file

	URLConnection urlCon = url.openConnection();
	urlCon.setDoInput(false);
	urlCon.setDoOutput(true);
	urlCon.setUseCaches(false);
	urlCon.setAllowUserInteraction(false);

	// When writing to a HTTP URI, a HTTP PUT is performed.
	if (urlCon instanceof HttpURLConnection) {
	HttpURLConnection httpCon = (HttpURLConnection) urlCon;
	httpCon.setRequestMethod("PUT");
	}
	urlOutStream = urlCon.getOutputStream();
	}
	// set the OutputStream to that obtained from the systemId
	serializer.setWriter(new OutputStreamWriter(urlOutStream));
	}
	} else {
	// 2.LSOutput.byteStream
	serializer.setWriter(new OutputStreamWriter(outputStream, fEncoding));
	}
	} else {
	// 1.LSOutput.characterStream
	serializer.setWriter(writer);
	}

	// The associated media type by default is set to text/xml on
	// org.apache.xml.serializer.SerializerBase.

	// Get a reference to the serializer then lets you serilize a DOM
	// Use this hack till Xalan support JAXP1.3
	if (fDOMSerializer == null) {
	fDOMSerializer = (DOM3Serializer)serializer.asDOM3Serializer();
	}

	// Set the error handler on the DOM3Serializer interface implementation
	if (fDOMErrorHandler != null) {
	fDOMSerializer.setErrorHandler(fDOMErrorHandler);
	}

	// Set the filter on the DOM3Serializer interface implementation
	if (fSerializerFilter != null) {
	fDOMSerializer.setNodeFilter(fSerializerFilter);
	}

	// Set the NewLine character to be used
	fDOMSerializer.setNewLine(fEndOfLine);

	// Serializer your DOM, where node is an org.w3c.dom.Node
	// Assuming that Xalan's serializer can serialize any type of DOM node
	fDOMSerializer.serializeDOM3(nodeArg);

	} catch( UnsupportedEncodingException ue) {

	String msg = Utils.messages
	.createMessage(
	MsgKey.ER_UNSUPPORTED_ENCODING,
	null);
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, msg,
	MsgKey.ER_UNSUPPORTED_ENCODING, ue));
	}
	throw new LSException(LSException.SERIALIZE_ERR, ue.getMessage());
	} catch (LSException lse) {
	// Rethrow LSException.
	throw lse;
	} catch (RuntimeException e) {
	e.printStackTrace();
	throw new LSException(LSException.SERIALIZE_ERR, e!=null?e.getMessage():"NULL Exception") ;
	} catch (Exception e) {
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, e.getMessage(),
	null, e));
	}
	e.printStackTrace();
	throw new LSException(LSException.SERIALIZE_ERR, e.toString());
	}
	return true;
	}

	/**
	* Serializes the specified node and returns a String with the serialized
	* data to the caller.
	*
	* @see org.w3c.dom.ls.LSSerializer#writeToString(org.w3c.dom.Node)
	* @since DOM Level 3
	* @param nodeArg The Node to serialize.
	* @throws org.w3c.dom.ls.LSException SERIALIZE_ERR: Raised if the
	* LSSerializer was unable to serialize the node.
	*
	*/
	public String writeToString(Node nodeArg) throws DOMException, LSException {
	// return null is nodeArg is null. Should an Exception be thrown instead?
	if (nodeArg == null) {
	return null;
	}

	// Should we reset the serializer configuration before each write operation?
	// Obtain a reference to the serializer to use
	Serializer serializer = fXMLSerializer;
	serializer.reset();

	if (nodeArg != fVisitedNode){
	// Determine the XML Document version of the Node
	String xmlVersion = getXMLVersion(nodeArg);

	serializer.getOutputFormat().setProperty("version", xmlVersion);

	// Set the output encoding and xml version properties
	fDOMConfigProperties.setProperty(DOMConstants.S_XERCES_PROPERTIES_NS + DOMConstants.S_XML_VERSION, xmlVersion);
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_ENCODING, "UTF-16");

	// If the node to be serialized is not a Document, Element, or Entity
	// node
	// then the XML declaration, or text declaration, should be never be
	// serialized.
	if ((nodeArg.getNodeType() != Node.DOCUMENT_NODE
	\|\| nodeArg.getNodeType() != Node.ELEMENT_NODE
	\|\| nodeArg.getNodeType() != Node.ENTITY_NODE)
	&& ((fFeatures & XMLDECL) != 0)) {
	fDOMConfigProperties.setProperty(
	DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL,
	DOMConstants.DOM3_DEFAULT_FALSE);
	}

	fVisitedNode = nodeArg;
	}
	// Update the serializer properties
	fXMLSerializer.setOutputFormat(fDOMConfigProperties);

	// StringWriter to Output to
	StringWriter output = new StringWriter();

	//
	try {

	// Set the Serializer's Writer to a StringWriter
	serializer.setWriter(output);

	// Get a reference to the serializer then lets you serilize a DOM
	// Use this hack till Xalan support JAXP1.3
	if (fDOMSerializer == null) {
	fDOMSerializer = (DOM3Serializer)serializer.asDOM3Serializer();
	}

	// Set the error handler on the DOM3Serializer interface implementation
	if (fDOMErrorHandler != null) {
	fDOMSerializer.setErrorHandler(fDOMErrorHandler);
	}

	// Set the filter on the DOM3Serializer interface implementation
	if (fSerializerFilter != null) {
	fDOMSerializer.setNodeFilter(fSerializerFilter);
	}

	// Set the NewLine character to be used
	fDOMSerializer.setNewLine(fEndOfLine);

	// Serializer your DOM, where node is an org.w3c.dom.Node
	fDOMSerializer.serializeDOM3(nodeArg);
	} catch (LSException lse) {
	// Rethrow LSException.
	throw lse;
	} catch (RuntimeException e) {
	e.printStackTrace();
	throw new LSException(LSException.SERIALIZE_ERR, e.toString());
	} catch (Exception e) {
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, e.getMessage(),
	null, e));
	}
	e.printStackTrace();
	throw new LSException(LSException.SERIALIZE_ERR, e.toString());
	}

	// return the serialized string
	return output.toString();
	}

	/**
	* Serializes the specified node to the specified URI and returns true if the Node
	* was successfully serialized.
	*
	* @see org.w3c.dom.ls.LSSerializer#writeToURI(org.w3c.dom.Node, String)
	* @since DOM Level 3
	* @param nodeArg The Node to serialize.
	* @throws org.w3c.dom.ls.LSException SERIALIZE_ERR: Raised if the
	* LSSerializer was unable to serialize the node.
	*
	*/
	public boolean writeToURI(Node nodeArg, String uri) throws LSException {
	// If nodeArg is null, return false. Should we throw and LSException instead?
	if (nodeArg == null ) {
	return false;
	}

	// Obtain a reference to the serializer to use
	Serializer serializer = fXMLSerializer;
	serializer.reset();

	if (nodeArg != fVisitedNode) {
	// Determine the XML Document version of the Node
	String xmlVersion = getXMLVersion(nodeArg);

	// Determine the encoding: 1.LSOutput.encoding,
	// 2.Document.inputEncoding, 3.Document.xmlEncoding.
	fEncoding = getInputEncoding(nodeArg);
	if (fEncoding == null ) {
	fEncoding = fEncoding != null ? fEncoding : getXMLEncoding(nodeArg) == null? "UTF-8": getXMLEncoding(nodeArg);
	}

	serializer.getOutputFormat().setProperty("version", xmlVersion);

	// Set the output encoding and xml version properties
	fDOMConfigProperties.setProperty(DOMConstants.S_XERCES_PROPERTIES_NS + DOMConstants.S_XML_VERSION, xmlVersion);
	fDOMConfigProperties.setProperty(DOMConstants.S_XSL_OUTPUT_ENCODING, fEncoding);

	// If the node to be serialized is not a Document, Element, or Entity
	// node
	// then the XML declaration, or text declaration, should be never be
	// serialized.
	if ( (nodeArg.getNodeType() != Node.DOCUMENT_NODE
	\|\| nodeArg.getNodeType() != Node.ELEMENT_NODE
	\|\| nodeArg.getNodeType() != Node.ENTITY_NODE)
	&& ((fFeatures & XMLDECL) != 0)) {
	fDOMConfigProperties.setProperty(
	DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL,
	DOMConstants.DOM3_DEFAULT_FALSE);
	}

	fVisitedNode = nodeArg;
	}

	// Update the serializer properties
	fXMLSerializer.setOutputFormat(fDOMConfigProperties);

	//
	try {
	// If the specified encoding is not supported an
	// "unsupported-encoding" fatal error is raised. ??
	if (uri == null) {
	String msg = Utils.messages.createMessage(
	MsgKey.ER_NO_OUTPUT_SPECIFIED, null);
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, msg,
	MsgKey.ER_NO_OUTPUT_SPECIFIED));
	}
	throw new LSException(LSException.SERIALIZE_ERR, msg);

	} else {
	// REVISIT: Can this be used to get an absolute expanded URI
	String absoluteURI = SystemIDResolver.getAbsoluteURI(uri);

	URL url = new URL(absoluteURI);
	OutputStream urlOutStream = null;
	String protocol = url.getProtocol();
	String host = url.getHost();

	// For file protocols, there is no need to use a URL to get its
	// corresponding OutputStream

	// Scheme names consist of a sequence of characters. The lower
	// case letters "a"--"z", digits, and the characters plus ("+"),
	// period ("."), and hyphen ("-") are allowed. For resiliency,
	// programs interpreting URLs should treat upper case letters as
	// equivalent to lower case in scheme names
	// (e.g., allow "HTTP" as well as "http").
	if (protocol.equalsIgnoreCase("file")
	&& (host == null \|\| host.length() == 0 \|\| host
	.equals("localhost"))) {
	// do we also need to check for host.equals(hostname)
	urlOutStream = new FileOutputStream(new File(url.getPath()));

	} else {
	// This should support URL's whose schemes are mentioned in
	// RFC1738 other than file

	URLConnection urlCon = url.openConnection();
	urlCon.setDoInput(false);
	urlCon.setDoOutput(true);
	urlCon.setUseCaches(false);
	urlCon.setAllowUserInteraction(false);

	// When writing to a HTTP URI, a HTTP PUT is performed.
	if (urlCon instanceof HttpURLConnection) {
	HttpURLConnection httpCon = (HttpURLConnection) urlCon;
	httpCon.setRequestMethod("PUT");
	}
	urlOutStream = urlCon.getOutputStream();
	}
	// set the OutputStream to that obtained from the systemId
	serializer.setWriter(new OutputStreamWriter(urlOutStream, fEncoding));
	}

	// Get a reference to the serializer then lets you serilize a DOM
	// Use this hack till Xalan support JAXP1.3
	if (fDOMSerializer == null) {
	fDOMSerializer = (DOM3Serializer)serializer.asDOM3Serializer();
	}

	// Set the error handler on the DOM3Serializer interface implementation
	if (fDOMErrorHandler != null) {
	fDOMSerializer.setErrorHandler(fDOMErrorHandler);
	}

	// Set the filter on the DOM3Serializer interface implementation
	if (fSerializerFilter != null) {
	fDOMSerializer.setNodeFilter(fSerializerFilter);
	}

	// Set the NewLine character to be used
	fDOMSerializer.setNewLine(fEndOfLine);

	// Serializer your DOM, where node is an org.w3c.dom.Node
	// Assuming that Xalan's serializer can serialize any type of DOM
	// node
	fDOMSerializer.serializeDOM3(nodeArg);

	} catch (LSException lse) {
	// Rethrow LSException.
	throw lse;
	} catch (RuntimeException e) {
	e.printStackTrace();
	throw new LSException(LSException.SERIALIZE_ERR, e.toString());
	} catch (Exception e) {
	if (fDOMErrorHandler != null) {
	fDOMErrorHandler.handleError(new DOMErrorImpl(
	DOMError.SEVERITY_FATAL_ERROR, e.getMessage(),
	null, e));
	}
	e.printStackTrace();
	throw new LSException(LSException.SERIALIZE_ERR, e.toString());
	}

	return true;
	}
	// ************************************************************************


	// ************************************************************************
	// Implementaion methods
	// ************************************************************************

	/**
	* Determines the XML Version of the Document Node to serialize. If the Document Node
	* is not a DOM Level 3 Node, then the default version returned is 1.0.
	*
	* @param nodeArg The Node to serialize
	* @return A String containing the version pseudo-attribute of the XMLDecl.
	* @throws Throwable if the DOM implementation does not implement Document.getXmlVersion()
	*/
	//protected String getXMLVersion(Node nodeArg) throws Throwable {
	protected String getXMLVersion(Node nodeArg) {
	Document doc = null;

	// Determine the XML Version of the document
	if (nodeArg != null) {
	if (nodeArg.getNodeType() == Node.DOCUMENT_NODE) {
	// The Document node is the Node argument
	doc = (Document)nodeArg;
	} else {
	// The Document node is the Node argument's ownerDocument
	doc = nodeArg.getOwnerDocument();
	}

	// Determine the DOM Version.
	if (doc != null && doc.getImplementation().hasFeature("Core","3.0")) {
	try {
	return doc.getXmlVersion();
	} catch (AbstractMethodError e) {
	//ignore, impl does not support the method
	}
	}
	}
	// The version will be treated as "1.0" which may result in
	// an ill-formed document being serialized.
	// If nodeArg does not have an ownerDocument, treat this as XML 1.0
	return "1.0";
	}

	/**
	* Determines the XML Encoding of the Document Node to serialize. If the Document Node
	* is not a DOM Level 3 Node, then the default encoding "UTF-8" is returned.
	*
	* @param nodeArg The Node to serialize
	* @return A String containing the encoding pseudo-attribute of the XMLDecl.
	* @throws Throwable if the DOM implementation does not implement Document.getXmlEncoding()
	*/
	protected String getXMLEncoding(Node nodeArg) {
	Document doc = null;

	// Determine the XML Encoding of the document
	if (nodeArg != null) {
	if (nodeArg.getNodeType() == Node.DOCUMENT_NODE) {
	// The Document node is the Node argument
	doc = (Document)nodeArg;
	} else {
	// The Document node is the Node argument's ownerDocument
	doc = nodeArg.getOwnerDocument();
	}

	// Determine the XML Version.
	if (doc != null && doc.getImplementation().hasFeature("Core","3.0")) {
	return doc.getXmlEncoding();
	}
	}
	// The default encoding is UTF-8 except for the writeToString method
	return "UTF-8";
	}

	/**
	* Determines the Input Encoding of the Document Node to serialize. If the Document Node
	* is not a DOM Level 3 Node, then null is returned.
	*
	* @param nodeArg The Node to serialize
	* @return A String containing the input encoding.
	*/
	protected String getInputEncoding(Node nodeArg) {
	Document doc = null;

	// Determine the Input Encoding of the document
	if (nodeArg != null) {
	if (nodeArg.getNodeType() == Node.DOCUMENT_NODE) {
	// The Document node is the Node argument
	doc = (Document)nodeArg;
	} else {
	// The Document node is the Node argument's ownerDocument
	doc = nodeArg.getOwnerDocument();
	}

	// Determine the DOM Version.
	if (doc != null && doc.getImplementation().hasFeature("Core","3.0")) {
	return doc.getInputEncoding();
	}
	}
	// The default encoding returned is null
	return null;
	}

	/**
	* This method returns the LSSerializer's error handler.
	*
	* @return Returns the fDOMErrorHandler.
	*/
	public DOMErrorHandler getErrorHandler() {
	return fDOMErrorHandler;
	}

	}

Back to index...