<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faqs PUBLIC "-//APACHE//DTD FAQ V1.0//EN" "../dtd/faq-v10.dtd">

<faqs title="Cocoon Sitemap Serializer FAQs">

<faq>
 <question>
  What is a serializer?
 </question>

 <answer>
  <p>
A serializer is the end point of an xml pipeline. It transforms SAX events into binary or char streams for final client consumption. Every pipeline match containing a generator must be terminated by a serializer. 
  </p>
  <p>
In the sitemap file, each serializer has a unique name which is mapped to a java class. One serializer name must be declared as the default serializer. Each serializer may have additional configuration information specified in child elements.
  </p>
  <p>
 For more conceptual information about serializers see <link href="../userdocs/concepts/sitemap.html">the sitemap</link>. For detailed descriptions about all of the available Cocoon serializers, see the user's guide document <link href="../userdocs/serializers/serializers.html">Serializers in Cocoon</link>. You may also wish to consult the Cocoon API documentation.
  </p>
</answer>
</faq>

<faq>
 <question>
  What is the easiest way to generate XHTML output?
 </question>

 <answer>
  <p>
I have an stylesheet which transforms XML to XHTML, but it seems that the 
serializer converts it to HTML. For example, I have some &lt;br/&gt; elements which are converted to  &lt;br&gt; elements. What can I do?
  </p>
  <p>
Cocoon has serializer configured for XHTML. First, make sure to declare it in
your sitemap's component section (within map:serializers).
  </p>
<source><![CDATA[
<map:serializer name="xhtml" mime-type="text/html"
  logger="sitemap.serializer.xhtml"
  src="org.apache.cocoon.serialization.XMLSerializer"
  pool-max="64" pool-min="2" pool-grow="2">
  <doctype-public>-//W3C//DTD XHTML 1.0 Strict//EN</doctype-public>
  <doctype-system>http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd</doctype-system>
 <encoding>UTF-8</encoding>
</map:serializer>  
]]></source>

  <p>
Then, in any pipeline, simply use the serializer as follows.
  </p>
  
<source><![CDATA[
<map:serialize type="xhtml" />
]]></source>

</answer>

</faq>

<faq>
 <question>
How can I remove the DTD declaration at the top of my HTML
pages created from pipelines with the default (HTML) serializer?
 </question>

 <answer>
  <p>
Within the map:components section of sitemap.xmap, adjust the configuration of your HTML serializer component as follows.
  </p>
<source><![CDATA[
<map:serializers default="html">

  <map:serializer name="html" mime-type="text/html; charset=ISO-8859-1"
     src="org.apache.cocoon.serialization.HTMLSerializer">
    <encoding>ISO-8859-1</encoding>
    <omit-xml-declaration>true</omit-xml-declaration>
  </map:serializer>
   
  <!-- other serializers -->
   
</map:serializers>
]]></source>

  <note>
Consider using the XMLSerializer in your pipeline. The XMLSerializer will not write a DocType Declaration.
  </note>
  
</answer>

</faq>

<faq>
 <question>
How can I remove namespaces from my xml files?
 </question>

 <answer>
  <p>
Sometimes adding xsl:exclude-result-prefixes attributes
to the &lt;xsl:stylesheet&gt; or literal result element is not effective
in removing all namespace declarations. For example, namespace nodes copied 
from the source document within &lt;xsl:copy&gt; or &lt;xsl:copy-of&gt; instructions 
(commonly found in catch-all stylesheet templates) will not be excluded.
  </p> 
  <p>
There are two approaches to this problem. 
  </p> 
    <p>
One approach is to extend your serializer component and override the startPrefixMapping and endPrefixMapping methods to do nothing. This will remove <strong>all</strong> namespaces from the serialized output. Since your serializer will no longer be processing namespaces, this theoretically will improve performance ever so slightly. You could generalize this approach by using the serializer's configuration method to declare namespaces to be excluded.
  </p>
 <p>
Another approach is to use an interim transformation step in your pipeline with a stylesheet described <link href="faq-xslt.html#faq-5">here</link>.
  </p>

  
</answer>

</faq>





</faqs>
