<?xml version="1.0" encoding="UTF-8"?>

	<!--
	 ***************************************************************
	 * 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.
	 ***************************************************************
   -->

<!-- A simple CAS consumer that writes an inline XML representation of the CAS to the filesystem.  -->

<casConsumerDescription xmlns="http://uima.apache.org/resourceSpecifier" xmlns:xi="http://www.w3.org/2001/XInclude">
	 
        <frameworkImplementation>org.apache.uima.cpp</frameworkImplementation>
        <implementationName>XCasWriterCasConsumer</implementationName>
         
	<processingResourceMetaData>

		<name>XCAS Writer CAS Consumer</name>
		<description>Writes the CAS to a stand-off XML format (XCAS)</description>
		<version>1.0</version>
		<vendor>IBM</vendor>

		<configurationParameters>
			<configurationParameter>
				<name>OutputDirectory</name>
				<description>The directory where xcas files are to be created.  The directory will be created if it does not exist.</description>
				<type>String</type>
				<multiValued>false</multiValued>
				<mandatory>false</mandatory>
			</configurationParameter>
		</configurationParameters>


          <!-- 
		<configurationParameterSettings>
			<nameValuePair>
				<name>OutputDirectory</name>
				<value>
					<string>xcasOutputDirectory</string>
				</value>
			</nameValuePair>
		</configurationParameterSettings>
          -->


	<typeSystemDescription>
             <types>
		<typeDescription>
			<name>org.apache.uima.examples.SourceDocumentInformation</name>
			<description>Stores detailed information about the original source document from which the current CAS was initialized. All information (like size) refers to the source document and not to the document in the CAS which may be converted and filtered by a CAS Initializer. For example this information will be written to the Semantic Search index so that the original document contents can be retrieved by queries.</description>
			<supertypeName>uima.tcas.Annotation</supertypeName>
			<features>
				<featureDescription>
					<name>uri</name>
					<description>URI of document. (For example, file:///MyDirectory/myFile.txt for a simple file or http://uima.apache.org for content from a web source.)</description>
					<rangeTypeName>uima.cas.String</rangeTypeName>
				</featureDescription>
				<featureDescription>
					<name>offsetInSource</name>
					<description>Byte offset of the start of document content within original source file or other input source. Only used if the CAS document was retrieved from an source where one physical source file contained several conceptual documents. Zero otherwise.</description>
					<rangeTypeName>uima.cas.Integer</rangeTypeName>
				</featureDescription>
				<featureDescription>
					<name>documentSize</name>
					<description>Size of original document in bytes before processing by CAS Initializer. Either absolute file size of size within file or other source.</description>
					<rangeTypeName>uima.cas.Integer</rangeTypeName>
				</featureDescription>
			</features>
		</typeDescription>
	    </types>
	</typeSystemDescription>

		<capabilities>
			<capability>
				<inputs>
          			<type allAnnotatorFeatures="true">org.apache.uima.examples.SourceDocumentInformation</type>
				</inputs>
			</capability>
		</capabilities>

	</processingResourceMetaData>

</casConsumerDescription>
