<?xml version="1.0" encoding="UTF-8"?>
<!--
        Basic sitemap for SDX. This sitemap has two important features :

            - all URIs with the .xsp extension are mapped to the
              XSP generator, with a single XSLT transformer which
              is in an 'xsl' subdirectory of the XSP page and has
              the same filename. For example, the /sdx/test/index.xsp
              uses the stylesheet located at /sdx/test/xsl/index.xsl.

            - an automount features that will mount sub sitemaps located
              in subdirectories beneath the /sdx directory. For instance,
              for a URI such has /sdx/test/index.xsp, the file
              /sdx/test/sitemap.xmap will be checked.

        The sitemap is the heart of Cocoon, thus the heart of SDX. For complete
        documentation, see the Cocoon documentation. For a sitemap with lots
        of examples, see the default sitemap shipped with Cocoon.
-->
<map:sitemap xmlns:map="http://apache.org/cocoon/sitemap/1.0">

<!-- =========================== Components ================================ -->

	<map:components>
	
		<!--+
		| All pipelines consist at least of two components: a generator, that
		| produces the content, and a serialiser, that delivers the content to
		| the client.
		| 
		| More precisely: a generator generates SAX events and a serializer
		| consumes these events and produces a byte stream.
		| 
		| Some things to note here: each generator has a unique name, this
		| name is mapped to a java class, one name is declared as the default
		| generator. Each generator may have additional configurations as
		| child elements.
		| 
		| Additional attributes are targeted at the component manager. The optional
		| "label" attribute is relevant for the view concept below. The optional
		| "logger" attribute defines the logging category where messages produced
		| by a component should go. If there's no "logger" attribute, the category
		| used is the one defined for the "sitemap" component in cocoon.xconf.
		| 
		| We have chosen in this sitemap to use a different logging category
		| for each component, which allows fine-grained classification of log
		| messages. But you are free to use any category you want.
		| 
		| It is possible to have the same java class declared as different
		| generators by using different names. No configuration options are
		| shared between these instances, however.
		| 
		| All components follow this scheme.
		+-->
		
		<map:generators default="file">
		
			<map:generator name="file" label="content,data" logger="sitemap.generator.file" pool-grow="4" pool-max="32" pool-min="8" src="org.apache.cocoon.generation.FileGenerator"/>
			<map:generator name="directory" label="content,data" logger="sitemap.generator.directory" pool-grow="2" pool-max="16" pool-min="2" src="org.apache.cocoon.generation.DirectoryGenerator"/>
			<map:generator name="imagedirectory" label="content" logger="sitemap.generator.imagedirectory" src="org.apache.cocoon.generation.ImageDirectoryGenerator"/>
			<map:generator name="mp3directory" label="content" logger="sitemap.generator.mp3directory" src="org.apache.cocoon.generation.MP3DirectoryGenerator"/>
			<map:generator name="request" label="content" logger="sitemap.generator.request" pool-grow="2" pool-max="16" pool-min="2" src="org.apache.cocoon.generation.RequestGenerator"/>
			<map:generator name="jx" label="content" logger="sitemap.generator.jx" pool-grow="2" pool-max="16" pool-min="2" src="org.apache.cocoon.generation.JXTemplateGenerator"/>
			<map:generator name="notifying" src="org.apache.cocoon.sitemap.NotifyingGenerator"/>
			<map:generator name="serverpages" label="content" logger="sitemap.generator.serverpages" pool-grow="2" pool-max="32" pool-min="4" src="org.apache.cocoon.generation.ServerPagesGenerator"/>
			<map:generator name="text" logger="sitemap.generator.text" src="org.apache.cocoon.generation.TextGenerator"/>
			<map:generator name="auth-conf" label="content" src="org.apache.cocoon.webapps.authentication.generation.ConfigurationGenerator"/>
			<map:generator name="jsp" label="content" src="org.apache.cocoon.generation.JSPGenerator"/>
			<map:generator name="html" label="content" logger="sitemap.generator.html" src="org.apache.cocoon.generation.HTMLGenerator"/>
			<map:generator name="profiler" label="content" logger="sitemap.generator.profiler" src="org.apache.cocoon.generation.ProfilerGenerator"/>
			<map:generator name="proxy" label="content" logger="sitemap.generator.proxy" src="org.apache.cocoon.generation.HttpProxyGenerator"/>
			<map:generator name="wsproxy" label="content" logger="sitemap.generator.wsproxy" src="org.apache.cocoon.generation.WebServiceProxyGenerator"/>
			<map:generator name="forms" logger="forms" src="org.apache.cocoon.forms.generation.FormsGenerator"/>
			<map:generator name="xsp" label="content,data" logger="sitemap.generator.serverpages" pool-max="32" pool-min="4" pool-grow="2" src="org.apache.cocoon.generation.ServerPagesGenerator"/>
			<map:generator name="asciiart-svg" logger="sitemap.generator.asciiart-svg" src="org.apache.cocoon.generation.asciiart.AsciiArtSVGGenerator"/>
			<map:generator name="extractor" label="content" logger="sitemap.generator.extractor" src="org.apache.cocoon.generation.FragmentExtractorGenerator"/>
			<!-- added from API -->
			<map:generator name="jelly" logger="sitemap.generator.jelly" src="org.apache.cocoon.generation.JellyGenerator"/>
			<!-- added from API -->
			<map:generator name="linkstatus" logger="sitemap.generator.linkstatus" src="org.apache.cocoon.generation.LinkStatusGenerator"/>
			<map:generator name="php" label="content" src="org.apache.cocoon.generation.PhpGenerator"/>
			<map:generator name="portal" label="content" src="org.apache.cocoon.webapps.portal.generation.PortalGenerator"/>
			<map:generator name="portal-conf" label="content" src="org.apache.cocoon.webapps.portal.generation.ConfigurationGenerator"/>
			<!-- added from API -->
			<map:generator name="req-attr" label="content" logger="sitemap.generator.req-attr" src="org.apache.cocoon.generation.RequestAttributeGenerator"/>
			<map:generator name="script" logger="sitemap.generation.scriptgenerator" src="org.apache.cocoon.generation.ScriptGenerator">
				<add-languages>
					<language name="groovy" src="org.codehaus.groovy.bsf.GroovyEngine">
						<extension>groovy</extension>
						<extension>gy</extension>
					</language>
				</add-languages>
			</map:generator>
			<map:generator name="search" src="org.apache.cocoon.generation.SearchGenerator"/>
			<map:generator name="slop" logger="sitemap.generator.slop" src="org.apache.cocoon.slop.generation.SlopGenerator"/>
			<map:generator name="status" label="content" logger="sitemap.generator.status" pool-grow="2" pool-max="16" pool-min="2" src="org.apache.cocoon.generation.StatusGenerator"/>
			<map:generator name="stream" label="content" logger="sitemap.generator.stream" pool-grow="2" pool-max="16" pool-min="1" src="org.apache.cocoon.generation.StreamGenerator"/>
			<!-- added from API -->
			<map:generator name="swf" logger="sitemap.generator.swf" src="org.apache.cocoon.generation.SWFGenerator"/>
			<!-- added from API -->
			<map:generator name="trax" logger="sitemap.generator.trax" src="org.apache.cocoon.generation.TraxGenerator"/>
			<map:generator name="velocity" label="content" logger="sitemap.generator.velocity" src="org.apache.cocoon.generation.VelocityGenerator"/>
			<map:generator name="xmidi" label="content" src="org.apache.cocoon.generation.XMidiGenerator"/>
			<map:generator name="xpathdirectory" label="content" logger="sitemap.generator.xpathdirectory" src="org.apache.cocoon.generation.XPathDirectoryGenerator"/>
			
		</map:generators>
		
		<!--+
		| Transformers can be placed inside the pipeline between the generator
		| and the serializer. You may have as many transformers as you
		| like. Transformers consume SAX events and emit SAX events.
		|
		| The "xslt" transformer is an example of a component with additional
		| configuration.
		+-->
		
		<map:transformers default="xsl">
		
			<map:transformer name="xsl" logger="sitemap.transformer.xslt" pool-max="32" pool-min="8" pool-grow="2" src="org.apache.cocoon.transformation.TraxTransformer"/>
			<map:transformer name="xslt" logger="sitemap.transformer.xslt" pool-grow="2" pool-max="32" pool-min="8" src="org.apache.cocoon.transformation.TraxTransformer">
				<use-request-parameters>false</use-request-parameters>
				<use-session-parameters>false</use-session-parameters>
				<use-cookie-parameters>false</use-cookie-parameters>
				<xslt-processor-role>xalan</xslt-processor-role>
				<check-includes>true</check-includes>
			</map:transformer>
			<map:transformer name="xalan" logger="sitemap.transformer.xalan" pool-grow="2" pool-max="32" pool-min="8" src="org.apache.cocoon.transformation.TraxTransformer">
				<use-request-parameters>false</use-request-parameters>
				<use-session-parameters>false</use-session-parameters>
				<use-cookie-parameters>false</use-cookie-parameters>
				<xslt-processor-role>xalan</xslt-processor-role>
				<check-includes>true</check-includes>
			</map:transformer>
			<map:transformer name="xsltc" logger="sitemap.transformer.xsltc" pool-grow="2" pool-max="32" pool-min="8" src="org.apache.cocoon.transformation.TraxTransformer">
				<use-request-parameters>false</use-request-parameters>
				<use-session-parameters>false</use-session-parameters>
				<use-cookie-parameters>false</use-cookie-parameters>
				<xslt-processor-role>xsltc</xslt-processor-role>
				<check-includes>true</check-includes>
			</map:transformer>
			<map:transformer name="xinclude" src="org.apache.cocoon.transformation.XIncludeTransformer" logger="sitemap.transformer.xinclude" pool-grow="2" pool-max="16" pool-min="2"/>
			<map:transformer name="cinclude" logger="sitemap.transformer.cinclude" pool-grow="2" pool-max="16" pool-min="2" src="org.apache.cocoon.transformation.CIncludeTransformer"/>
			<map:transformer name="log" logger="sitemap.transformer.log" pool-grow="2" pool-max="16" pool-min="2" src="org.apache.cocoon.transformation.LogTransformer"/>
			<map:transformer name="sql" logger="sitemap.transformer.sql" src="org.apache.cocoon.transformation.SQLTransformer"/>
		</map:transformers>
		
		<!--+
		| Readers circumvent the XML oriented SAX pipeline model, think of a reader
		| being a generator and a serializer at once thus a pipeline may not
		| contain any generator, transformer or serializer in addition to a
		| reader. They are useful for delivering binary content like images.
		+-->
		
		<map:readers default="resource">
		
			<map:reader name="resource" logger="sitemap.reader.resource" pool-max="32" src="org.apache.cocoon.reading.ResourceReader"/>
			<map:reader name="image" logger="sitemap.reader.image" src="org.apache.cocoon.reading.ImageReader"/>
			<map:reader name="dir-zip-archiver" logger="sitemap.reader.dir-zip-archiver" src="org.apache.cocoon.reading.DirectoryZipArchiver"/>
			
		</map:readers>
		
		<!--+
		| Serializers consume SAX events and produce a character stream. Every
		| pipeline needs to be terminated by a serializer.
		+-->
		
		<map:serializers default="html">
		
			<map:serializer name="html" src="org.apache.cocoon.serialization.HTMLSerializer" mime-type="text/html" logger="sitemap.serializer.html" pool-grow="4" pool-max="32" pool-min="4">
				<buffer-size>1024</buffer-size>
				<doctype-public>-//W3C//DTD HTML 4.01 Transitional//EN</doctype-public>
				<doctype-system>http://www.w3.org/TR/html4/loose.dtd</doctype-system>
				<encoding>UTF-8</encoding>
			</map:serializer>
			<map:serializer name="xml" src="org.apache.cocoon.serialization.XMLSerializer" mime-type="text/xml" logger="sitemap.serializer.xml">
				<encoding>UTF-8</encoding>
			</map:serializer>
			<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>
			<map:serializer name="xhtml11" logger="sitemap.serializer.xhtml" mime-type="application/xhtml+xml" pool-grow="2" pool-max="64" pool-min="2" src="org.apache.cocoon.serialization.XMLSerializer">
				<doctype-public>-//W3C//DTD XHTML 1.1//EN</doctype-public>
				<doctype-system>http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd</doctype-system>
				<encoding>UTF-8</encoding>
			</map:serializer>
			<map:serializer name="text" mime-type="text/plain" logger="sitemap.serializer.text" src="org.apache.cocoon.serialization.TextSerializer"/>
			<map:serializer name="svgxml" mime-type="image/svg-xml" logger="sitemap.serializer.svgxml" src="org.apache.cocoon.serialization.XMLSerializer">
				<doctype-public>-//W3C//DTD SVG 20000303 Stylable//EN</doctype-public>
				<doctype-system>http://www.w3.org/TR/2000/03/WD-SVG-20000303/</doctype-system>
			</map:serializer>
			<map:serializer name="ehtml" logger="sitemap.serializer.ehtml" mime-type="text/html" src="org.apache.cocoon.components.serializers.HTMLSerializer">
				<encoding>UTF-8</encoding>
			</map:serializer>
			<map:serializer name="exhtml" logger="sitemap.serializer.exhtml" mime-type="text/xhtml" src="org.apache.cocoon.components.serializers.XHTMLSerializer">
				<encoding>UTF-8</encoding>
			</map:serializer>
			<map:serializer name="exml" logger="sitemap.serializer.exml" mime-type="text/xml" src="org.apache.cocoon.components.serializers.XMLSerializer">
				<encoding>UTF-8</encoding>
			</map:serializer>

			<map:serializer name="fo2pcl" logger="sitemap.serializer.fo2pcl" mime-type="vnd.hp-PCL" src="org.apache.cocoon.serialization.FOPSerializer"/>
			<map:serializer name="fo2pdf" logger="sitemap.serializer.fo2pdf" mime-type="application/pdf" src="org.apache.cocoon.serialization.FOPSerializer"/>
			<map:serializer name="fo2ps" logger="sitemap.serializer.fo2ps" mime-type="application/postscript" src="org.apache.cocoon.serialization.FOPSerializer"/>
			<map:serializer name="fo2rtf" mime-type="application/msword" src="org.apache.cocoon.serialization.RTFSerializer"/>
			<map:serializer name="itext2pdf" mime-type="application/pdf" src="org.apache.cocoon.serialization.iTextSerializer"/>
			<map:serializer name="svg2jpeg" logger="sitemap.serializer.svg2jpeg" mime-type="image/jpeg" src="org.apache.cocoon.serialization.SVGSerializer">
				<parameter name="quality" type="float" value="0.9"/>
			</map:serializer>
			<map:serializer name="svg2png" logger="sitemap.serializer.svg2png" mime-type="image/png" src="org.apache.cocoon.serialization.SVGSerializer"/>
		</map:serializers>
		
		<!--+
		| Matchers are executed during pipeline setup. They decide if a
		| pipeline fragment is used within a pipeline. Usually, the decision
		| is based on a match on the requested URI but matchers exist, that
		| match different things as well. Most often the fragment contained in
		| a matcher has a generator as well as a serializer. This is not a
		| necessity, matchers can be nested while chaining does not work.
		+-->
		
		<map:matchers default="wildcard">
		
			<map:matcher name="wildcard" logger="sitemap.matcher.wildcard" src="org.apache.cocoon.matching.WildcardURIMatcher"/>
			<map:matcher name="regexp" logger="sitemap.matcher.regexp" src="org.apache.cocoon.matching.RegexpURIMatcher"/>
			
		</map:matchers>
		
		<!--+
		| Selectors are executed during pipeline setup. They can be used to
		| determine which pipeline fragments should be combined. They are best
		| compared with a java switch statement.
		+-->
		
		<map:selectors default="browser">
		
			<map:selector name="browser" logger="sitemap.selector.browser" src="org.apache.cocoon.selection.BrowserSelector">
				<browser name="explorer" useragent="MSIE"/>
				<browser name="pocketexplorer" useragent="MSPIE"/>
				<browser name="handweb" useragent="HandHTTP"/>
				<browser name="avantgo" useragent="AvantGo"/>
				<browser name="imode" useragent="DoCoMo"/>
				<browser name="opera" useragent="Opera"/>
				<browser name="lynx" useragent="Lynx"/>
				<browser name="java" useragent="Java"/>
				<browser name="wap" useragent="Nokia"/>
				<browser name="wap" useragent="UP"/>
				<browser name="wap" useragent="Wapalizer"/>
				<browser name="mozilla5" useragent="Mozilla/5"/>
				<browser name="mozilla5" useragent="Netscape6/"/>
				<browser name="netscape" useragent="Mozilla"/>
			</map:selector>
			<map:selector name="resource-exists" logger="sitemap.selector.resource-exists" src="org.apache.cocoon.selection.ResourceExistsSelector"/>
			<!-- -->
			<map:selector name="exception" logger="sitemap.selector.exception" src="org.apache.cocoon.selection.ExceptionSelector">
				<exception name="not-found" class="org.apache.cocoon.ResourceNotFoundException"/>
				<exception name="invalid-continuation" class="org.apache.cocoon.components.flow.InvalidContinuationException"/>
				<exception class="java.lang.Throwable" unroll="true"/>
			</map:selector>
			<map:selector name="simple" logger="sitemap.selector.simple" src="org.apache.cocoon.selection.SimpleSelector"/>
			<map:selector name="request-method" logger="sitemap.selector.request-method" src="org.apache.cocoon.selection.RequestMethodSelector"/>

			<map:selector name="parameter" logger="sitemap.selector.parameter" src="org.apache.cocoon.selection.ParameterSelector"/>
			<map:selector name="header" logger="sitemap.selector.header" src="org.apache.cocoon.selection.HeaderSelector"/>
			<map:selector name="host" logger="sitemap.selector.host" src="org.apache.cocoon.selection.HostSelector"/>
			<map:selector name="session-media" src="org.apache.cocoon.webapps.session.selection.MediaSelector"/>
			<!-- added from API -->
			<map:selector name="cookie" logger="sitemap.selector.cookie" src="org.apache.cocoon.selection.CookieSelector"/>
			<map:selector name="xpathexception" logger="sitemap.selector.xpathexception" src="org.apache.cocoon.selection.XPathExceptionSelector"/>
			<map:selector name="date" logger="sitemap.selector.date" src="org.apache.cocoon.selection.DateSelector"/>
			
		</map:selectors>
		
		<!--+
		| Actions are executed during pipeline setup. Their purpose is to
		| execute some code that doesn't involve touching the stream of
		| pipeline events. Example usage is to update databases, check external 
		| resources, etc.. The execution may fail or complete successfully. Only 
		| if the execution of the action was successful, the pipeline fragment 
		| nested inside the action element is executed, otherwise, it's skipped
		| entirely and execution proceeds from the element right below the action.
		+-->
		
		<map:actions>
      <!-- 2005-05-03 [FG] test if a resource answer -->
			<map:action name="resource-exists" logger="sitemap.action.resource-exists" src="org.apache.cocoon.acting.ResourceExistsAction"/>
			<!-- 
2005-05-03 [FG] session actions are not really documented and well designed
                seems to be overriden by the session-fw block
                SDX has its own framework
       -->
			<!-- 2005-05-03 [FG] important action  -->
			<map:action name="clear-cache" logger="sitemap.action.clear-cache" src="org.apache.cocoon.acting.ClearCacheAction"/>
			<!-- 2005-05-03 [FG] unuseful till there's persistent store configure by SDX cocoon.xconf -->
			<map:action name="clear-persistent-store" logger="sitemap.action.clear-persistent-store" src="org.apache.cocoon.acting.ClearPersistentStoreAction"/>
			<map:action name="locale" logger="sitemap.action.locale" src="org.apache.cocoon.acting.LocaleAction"/>
      <!-- 2005-05-03 [FG] allow to implement action as xsp -->
			<map:action name="xsp" logger="sitemap.action.serverpages" pool-grow="2" pool-max="32" pool-min="4" src="org.apache.cocoon.acting.ServerPagesAction"/>
			<!-- 2005-05-03 [FG] allow to copy generated content somewhere on the file system -->
			<map:action name="copy-source" logger="sitemap.action.copysource" src="org.apache.cocoon.acting.CopySourceAction"/>
		</map:actions>
		
		<!--+
		| The different pipe implementations
		| 
		| NON-CACHING:
		|   The non caching implementation of cocoon pipelines.
		| 
		| CACHING:
		|   Traditional longest cacheable key caching.
		| 
		| CACHING-POINT:
		|   The caching-point pipeline implements an extended             
		|   caching algorithm which is of particular benefit for use with 
		|   those pipelines that utilise cocoon-views and/or provide      
		|   drill-down functionality.                                     
		| 
		| The autoCachingPoint algorithim (if enabled) will automatically
		| cache common elements of the pipeline currently being processed - as well
		| as the entire cacheable pipeline according to the "longest cacheable key"
		| algorithm.
		| 
		| Consider the following simple pipeline, where generator G is labelled with
		| a cocoon-view enabling the pipeline to serialize data to either html or pdf 
		| depending on the value of cocoon-view (as provided by the request):
		| G - T -  S(html)
		| |__ T -  S(pdf)
		| 
		| If cocoon-view=html, then the caching-point algorithm will not only cache 
		| the longest cacheable path, which would be GTS(html) but also the
		| *common element* which in this case would be the results from G. If the
		| next request to this pipeline was cocoon-view=pdf, then there would be no
		| need to invoke the generator a second time, as it's value has already been
		| cached (provided G generates the same cache key)
		| 
		| Also note: One can switch "Off" autoCachingPoint and use "pipeline-hints" to
		| manually indicate that certain pipeline-components should be considered as
		| cache points.
		+-->
		
		<map:pipes default="caching">
		
			<map:pipe name="caching" src="org.apache.cocoon.components.pipeline.impl.CachingProcessingPipeline"/>
			<map:pipe name="caching-point" src="org.apache.cocoon.components.pipeline.impl.CachingPointProcessingPipeline">
				<parameter name="autoCachingPoint" value="On"/>
			</map:pipe>
			<map:pipe name="noncaching" src="org.apache.cocoon.components.pipeline.impl.NonCachingProcessingPipeline"/>
			<map:pipe name="profile-caching" src="org.apache.cocoon.components.profiler.ProfilingCachingProcessingPipeline"/>
			<map:pipe name="profile-noncaching" src="org.apache.cocoon.components.profiler.ProfilingNonCachingProcessingPipeline"/>
			<map:pipe name="base-caching" src="org.apache.cocoon.components.pipeline.impl.BaseCachingProcessingPipeline"/>
			
		</map:pipes>
		
	</map:components>
	
	
<!-- =========================== Resources ================================= -->

	<!--+
	| Resources are pipeline fragments that may be used from different
	| pipeline fragments. For our needs, they behave exactly like
	| pipelines, only that they are not accessible from outside.
	| Hence I will explain what's inside below for pipelines.
	+-->
	
	<map:resources>
	
		<map:resource name="static">
			<!--
			theese mime types are directly send to the client if a resource answer, 
			if not, process should be continue on sub-sitemaps (ResourceExistsAction)
			-->
			
			<!-- text -->
			<map:match pattern="**.asc">
				<map:read src="{1}.asc" mime-type="text/plain"/>
			</map:match>
			<map:match pattern="**.css">
				<map:read src="{1}.css" mime-type="text/css"/>
			</map:match>
			<map:match pattern="**.dtd">
				<map:read src="{1}.dtd" mime-type="text/plain"/>
			</map:match>
			<map:match pattern="**.htm">
				<map:read src="{1}.htm" mime-type="text/html"/>
			</map:match>
			<map:match pattern="**.html">
				<map:read src="{1}.html" mime-type="text/html"/>
			</map:match>
			<map:match pattern="**.java">
				<map:read src="{1}.java" mime-type="text/x-java-source"/>
			</map:match>
			<map:match pattern="**.js">
				<map:read src="{1}.js" mime-type="text/javascript"/>
			</map:match>
			<map:match pattern="**.tsv">
				<map:read src="{1}.tsv" mime-type="text/tab-separated-values"/>
			</map:match>
			<map:match pattern="**.text">
				<map:read src="{1}.text" mime-type="text/plain"/>
			</map:match>
			<map:match pattern="**.txt">
				<map:read src="{1}.txt" mime-type="text/plain"/>
			</map:match>
			<map:match pattern="**.vcf">
				<map:read src="{1}.vcf" mime-type="text/x-vcard"/>
			</map:match>
			<map:match pattern="**.xml">
				<map:read src="{1}.xml" mime-type="text/xml"/>
			</map:match>
			<!-- image -->
			<map:match pattern="**.bmp">
				<map:read src="{1}.bmp" mime-type="image/bmp"/>
			</map:match>
			<map:match pattern="**.gif">
				<map:read src="{1}.gif" mime-type="image/gif"/>
			</map:match>
			<map:match pattern="**.jpe">
				<map:read src="{1}.jpe" mime-type="image/jpeg"/>
			</map:match>
			<map:match pattern="**.jpeg">
				<map:read src="{1}.jpeg" mime-type="image/jpeg"/>
			</map:match>
			<map:match pattern="**.jpg">
				<map:read src="{1}.jpg" mime-type="image/jpeg"/>
			</map:match>
			<map:match pattern="**.pbm">
				<map:read src="{1}.pbm" mime-type="image/x-portable-bitmap"/>
			</map:match>
			<map:match pattern="**.pgm">
				<map:read src="{1}.pgm" mime-type="image/x-portable-graymap"/>
			</map:match>
			<map:match pattern="**.png">
				<map:read src="{1}.png" mime-type="image/png"/>
			</map:match>
			<map:match pattern="**.ppm">
				<map:read src="{1}.ppm" mime-type="image/x-portable-pixmap"/>
			</map:match>
			<map:match pattern="**.rgb">
				<map:read src="{1}.rgb" mime-type="image/x-rgb"/>
			</map:match>
			<map:match pattern="**.svg">
				<map:read src="{1}.svg" mime-type="image/svg-xml"/>
			</map:match>
			<map:match pattern="**.tif">
				<map:read src="{1}.tif" mime-type="image/tiff"/>
			</map:match>
			<map:match pattern="**.tiff">
				<map:read src="{1}.tiff" mime-type="image/tiff"/>
			</map:match>
			<!-- audio -->
			<map:match pattern="**.aif">
				<map:read src="{1}.aif" mime-type="audio/x-aiff"/>
			</map:match>
			<map:match pattern="**.aifc">
				<map:read src="{1}.aifc" mime-type="audio/x-aiff"/>
			</map:match>
			<map:match pattern="**.aiff">
				<map:read src="{1}.aiff" mime-type="audio/x-aiff"/>
			</map:match>
			<map:match pattern="**.au">
				<map:read src="{1}.au" mime-type="audio/basic"/>
			</map:match>
			<map:match pattern="**.mid">
				<map:read src="{1}.mid" mime-type="audio/midi"/>
			</map:match>
			<map:match pattern="**.midi">
				<map:read src="{1}.midi" mime-type="audio/midi"/>
			</map:match>
			<map:match pattern="**.mp3">
				<map:read src="{1}.mp3" mime-type="audio/mpeg"/>
			</map:match>
			<map:match pattern="**.mp3">
				<map:read src="{1}.mp3" mime-type="audio/mpeg"/>
			</map:match>
			<map:match pattern="**.mpe">
				<map:read src="{1}.mpe" mime-type="audio/mpeg"/>
			</map:match>
			<map:match pattern="**.mpeg">
				<map:read src="{1}.mpeg" mime-type="audio/mpeg"/>
			</map:match>
			<map:match pattern="**.mpg">
				<map:read src="{1}.mpg" mime-type="audio/mpeg"/>
			</map:match>
			<map:match pattern="**.ra">
				<map:read src="{1}.ra" mime-type="audio/x-pn-realaudio"/>
			</map:match>
			<map:match pattern="**.ram">
				<map:read src="{1}.ram" mime-type="audio/x-pn-realaudio"/>
			</map:match>
			<map:match pattern="**.rm">
				<map:read src="{1}.rm" mime-type="audio/x-pn-realaudio"/>
			</map:match>
			<map:match pattern="**.snd">
				<map:read src="{1}.snd" mime-type="audio/basic"/>
			</map:match>
			<!-- video -->
			<map:match pattern="**.avi">
				<map:read src="{1}.avi" mime-type="video/x-msvideo"/>
			</map:match>
			<map:match pattern="**.mov">
				<map:read src="{1}.mov" mime-type="video/quicktime"/>
			</map:match>
			<map:match pattern="**.qt">
				<map:read src="{1}.qt" mime-type="video/quicktime"/>
			</map:match>
			<!-- application -->
			<map:match pattern="**.ai">
				<map:read src="{1}.ai" mime-type="application/postscript"/>
			</map:match>
			<map:match pattern="**.class">
				<map:read src="{1}.class" mime-type="application/java-class"/>
			</map:match>
			<map:match pattern="**.eps">
				<map:read src="{1}.eps" mime-type="application/postscript"/>
			</map:match>
			<map:match pattern="**.gz">
				<map:read src="{1}.gz" mime-type="application/x-gzip"/>
			</map:match>
			<map:match pattern="**.jar">
				<map:read src="{1}.jar" mime-type="application/java-archive"/>
			</map:match>
			<map:match pattern="**.jnlp">
				<map:read src="{1}.jnlp" mime-type="application/x-java-jnlp-file"/>
			</map:match>
			<map:match pattern="**.pdf">
				<map:read src="{1}.pdf" mime-type="application/pdf"/>
			</map:match>
			<map:match pattern="**.ps">
				<map:read src="{1}.ps" mime-type="application/postscript"/>
			</map:match>
			<map:match pattern="**.rtf">
				<map:read src="{1}.rtf" mime-type="application/rtf"/>
			</map:match>
			<map:match pattern="**.rtx">
				<map:read src="{1}.rtx" mime-type="application/richtext"/>
			</map:match>
			<map:match pattern="**.ser">
				<map:read src="{1}.ser" mime-type="application/x-java-serialized-object"/>
			</map:match>
			<map:match pattern="**.shtml">
				<map:read src="{1}.shtml" mime-type="application/x-server-parsed-html"/>
			</map:match>
			<map:match pattern="**.ssi">
				<map:read src="{1}.shtml" mime-type="application/x-server-parsed-html"/>
			</map:match>
			<map:match pattern="**.swf">
				<map:read src="{1}.swf" mime-type="application/x-shockwave-flash"/>
			</map:match>
			<map:match pattern="**.tar">
				<map:read src="{1}.tar" mime-type="application/x-tar"/>
			</map:match>
			<map:match pattern="**.wav">
				<map:read src="{1}.wav" mime-type="audio/wav"/>
			</map:match>
			<map:match pattern="**.zip">
				<map:read src="{1}.zip" mime-type="application/zip"/>
			</map:match>
			<!-- misc -->
			<map:match pattern="**.wml">
				<map:read src="{1}.wml" mime-type="x-world/x-vrml"/>
			</map:match>
			
		</map:resource>
		
	</map:resources>
	
<!-- ========================== Action sets ================================ -->

	<!--+
	| Action sets group actions together. If some actions are often used
	| together in pipeline fragments, it's easier to group them and refer
	| to the group. For more info, please see the docs.
	+-->	
	
	<map:action-sets/>
	
<!-- =========================== Pipelines ================================= -->

	<!--+
	| Pipelines. The beef. Pipelines specify how the processing of your
	| content is done. Usually, a pipeline consists of several fragments
	| that specify the generation, transformation, and serialization of
	| SAX events.
	|
	| Processing is done in two steps:
	|
	| 1) The top level elements are executed in order of appearance until
	|    one signals success. These top level elements are usually
	|    matchers.
	|
	|    Other components are called depth-first to determine what
	|    fragments make up the processing pipeline. When a component
	|    fails, no nested components are called but the next component on
	|    the same level.
	|
	| 2) Once it is determined which generator, which transformers and
	|    wich serializer is used, these components are executed. During
	|    this, the pipeline may not be changed.
	|
	| You may have as many pipelines in your sitemap as you like.
	+-->
	
	<map:pipelines>
	
		<map:pipeline>
		
			<!-- A default welcome page -->
			<map:match pattern="">
				<map:redirect-to uri="sdx/"/>
			</map:match>
			<!-- go to an app -->
			<!-- 2005-04-29 [FG] the favicon.ico bug, test if folder exists before redirecting -->
			<map:match pattern="*">
         <map:select type="resource-exists">
            <map:when test="{1}">
              <map:redirect-to uri="{1}/"/>
            </map:when>
        </map:select>
			</map:match>
			<!-- process static resources if available -->
			<map:match pattern="**.*">
				<map:act type="resource-exists">
					<map:parameter name="url" value="context://{1}.{2}"/>
					<map:call resource="static"/>
				</map:act>
			</map:match>
			<!--     "automount" setup                                                
			This causes directories added under sdx                           
			(even with Cocoon already running) to be activated automatically  
			if they contain a sitemap.xmap, without having to modify the main 
			sitemap.xmap                                                      
			!!! caution : now you need a sitemap in all subdirectories !!!    

      2005-04-29 [FG] the favicon.ico bug, test if sitemap.xmap exists before mount  
			-->
			<map:match pattern="*/**">
         <map:select type="resource-exists">
            <map:when test="{1}/sitemap.xmap">
              <map:mount uri-prefix="{1}" src="{1}/" check-reload="yes"/>
            </map:when>
        </map:select>
			</map:match>
			<!-- A default not found page, here send on welcome
			<map:match pattern="**">
			<map:redirect-to uri=""/>
			</map:match>
			-->
			<!-- personal error page -->
			<map:handle-errors>
				<map:generate type="notifying"/>
				<map:transform src="sdx/resources/xsl/error.xsl"/>
				<map:serialize status-code="500"/>
			</map:handle-errors>
			
		</map:pipeline>
		
	</map:pipelines>
	
</map:sitemap>
