/*
* 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 org.apache.uima.cas.impl;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import org.apache.uima.UimaContext;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.TypeSystem;
import org.apache.uima.internal.util.IntStack;
import org.apache.uima.internal.util.IntVector;
import org.apache.uima.internal.util.StringUtils;
import org.apache.uima.internal.util.rb_trees.IntRedBlackTree;
import org.apache.uima.util.XMLSerializer;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
/**
* XCAS serializer. Create a serializer from a type system, then encode individual CASes by writing
* to a SAX content handler. This class is thread safe.
*
*
*/
public class XCASSerializer {
private int numChildren;
public int getNumChildren() {
return numChildren;
}
/**
* Use an inner class to hold the data for serializing a CAS. Each call to serialize() creates its
* own instance.
*
*
*/
private class XCASDocSerializer {
// Where the output goes.
// private SAXDocStack xmlStack;
private ContentHandler ch;
// The CAS we're serializing.
private CASImpl cas;
// Any FS reference we've touched goes in here.
private IntRedBlackTree queued;
private static final int NOT_INDEXED = -1;
private static final int MULTIPLY_INDEXED = -2;
private static final int INVALID_INDEX = -3;
// Any FS indexed in more than one IR goes in here
private IntRedBlackTree duplicates;
// Number of FS indexed in more than one IR
int numDuplicates;
// Vector of IntVectors for duplicates
Vector dupVectors;
// All FSs that are in an index somewhere.
private IntVector indexedFSs;
// Specific IndexRepository for indexed FSs
private IntVector indexReps;
// The current queue for FSs to write out.
private IntStack queue;
// SofaFS type
private int sofaTypeCode;
private final AttributesImpl emptyAttrs = new AttributesImpl();
private AttributesImpl workAttrs = new AttributesImpl();
private static final String cdataType = "CDATA";
// For debug statistics.
private int fsCount = 0;
// Out-Of-TypeSystem Data to be included in produced XCAS. (APL)
private OutOfTypeSystemData mOutOfTypeSystemData;
// We write to a SAXDocStack, a simplified interface to a
// ContentHandler.
private XCASDocSerializer(ContentHandler ch, CASImpl cas) {
super();
this.ch = ch;
this.cas = cas;
this.queued = new IntRedBlackTree();
this.duplicates = new IntRedBlackTree();
this.numDuplicates = 0;
this.dupVectors = new Vector();
this.queue = new IntStack();
this.indexedFSs = new IntVector();
this.indexReps = new IntVector();
this.sofaTypeCode = cas.ll_getTypeSystem().ll_getCodeForType(
cas.getTypeSystem().getType(CAS.TYPE_NAME_SOFA));
// Why was this here? Was never being read anywhere:
// fs = new FeatureStructureImplC(cas, 0);
}
/**
* Add an address to the queue.
*
* @param addr
* The address.
* @return <code>false</code> iff we've seen this address before.
*/
private boolean enqueue(int addr) {
if (KEY_ONLY_MATCH == isQueued(addr, INVALID_INDEX)) {
return false;
}
int heapVal = cas.getHeapValue(addr);
// at this point we don't know if this FS is indexed
queued.put(addr, NOT_INDEXED);
queue.push(addr);
final int typeClass = classifyType(heapVal);
if (typeClass == LowLevelCAS.TYPE_CLASS_FS) {
if (mOutOfTypeSystemData != null) {
enqueueOutOfTypeSystemFeatures(addr);
}
enqueueFeatures(addr, heapVal);
} else if (typeClass == LowLevelCAS.TYPE_CLASS_FSARRAY) {
enqueueFSArray(addr);
}
return true;
}
/**
* Same as enqueue, but for indexed FSs.
*
* @param addr
* The address to enqueue.
*/
private void enqueueIndexed(int addr, int indexRep) {
int status = isQueued(addr, indexRep);
switch (status) {
case KEY_NOT_FOUND: // most common case, key not found
queued.put(addr, indexRep);
indexedFSs.add(addr);
indexReps.add(indexRep);
break;
case KEY_AND_VALUE_MATCH: // next most common, FS already queued
break;
case KEY_ONLY_MATCH: // key is there, indexRep not
int prevIndex = queued.get(addr);
if (NOT_INDEXED == prevIndex) {
// this addr added from a previously found reference
queued.put(addr, indexRep); // set with given index
break;
}
if (MULTIPLY_INDEXED == prevIndex) {
// this addr already indexed more than once
int thisDup = duplicates.get(addr);
((IntVector) dupVectors.get(thisDup)).add(indexRep);
break;
}
// duplicate index detected!
duplicates.put(addr, numDuplicates);
dupVectors.add(new IntVector());
((IntVector) dupVectors.get(numDuplicates)).add(prevIndex);
((IntVector) dupVectors.get(numDuplicates)).add(indexRep);
numDuplicates++;
queued.put(addr, MULTIPLY_INDEXED); // mark this addr as multiply indexed
break;
}
return;
}
/**
* Bad name; check if we've seen this (address, value) before.
*
* @param addr
* The address.
* @param value
* The index repository
* @return KEY_AND_VALUE_MATCH iff we've seen (address, value) before. KEY_NOT_FOUND iff the
* address has not been seen before. KEY_ONLY_MATCH iff the address has been seen before
* with a different value.
*/
private static final int KEY_AND_VALUE_MATCH = 1;
private static final int KEY_ONLY_MATCH = -1;
private static final int KEY_NOT_FOUND = 0;
private int isQueued(int addr, int value) {
return containsKeyValuePair(this.queued, addr, value);
}
// returns
// KEY_AND_VALUE_MATCH = 1;
// KEY_ONLY_MATCH = -1;
// KEY_NOT_FOUND = 0;
private final int containsKeyValuePair(IntRedBlackTree rbt, int key, int value) {
if (rbt.containsKey(key)) {
if (rbt.get(key) == value) {
return KEY_AND_VALUE_MATCH;
}
return KEY_ONLY_MATCH;
}
return KEY_NOT_FOUND;
}
/**
* Version of serialize which also includes OutOfTypeSystemData (obtained from previous
* deserialization) in the produced XCAS.
*
* @throws XMLException
* @throws IOException
* @throws SAXException
*/
private void serialize(boolean encodeDoc, OutOfTypeSystemData outOfTypeSystemData)
throws IOException, SAXException {
mOutOfTypeSystemData = outOfTypeSystemData;
int iElementCount = 0;
enqueueIndexed();
enqueueFeaturesOfIndexed();
if (outOfTypeSystemData != null) {
// Queues out of type system data.
int nextId = cas.getHeap().getCurrentTempSize();
Iterator it = outOfTypeSystemData.fsList.iterator();
while (it.hasNext()) {
FSData fs = (FSData) it.next();
String newId = Integer.toString(nextId++);
outOfTypeSystemData.idMap.put(fs.id, newId);
fs.id = newId;
}
iElementCount += outOfTypeSystemData.fsList.size();
enqueueOutOfTypeSystemData(outOfTypeSystemData);
}
iElementCount += indexedFSs.size();
iElementCount += queue.size();
AttributesImpl rootAttrs = new AttributesImpl();
rootAttrs.addAttribute(null, null, VERSION_ATTR, cdataType, CURRENT_VERSION);
startElement(casTagName, rootAttrs, iElementCount);
// continue with serialization
encodeIndexed(); // encodes indexedFSs.size() elements
encodeQueued(); // encodes queue.size() elements
if (outOfTypeSystemData != null) {
// encodes aData.fsList.size() elements
serializeOutOfTypeSystemData(outOfTypeSystemData);
}
endElement(casTagName);
}
private void addText(String text) throws SAXException {
ch.characters(text.toCharArray(), 0, text.length());
}
private String replaceInvalidXmlChars(String aString) {
// first do a scan, so we don't have to change anything if there are
// no
// bad charactes
boolean controlCharFound = false;
for (int i = 0; i < aString.length(); i++) {
if (!isValidXmlChar(aString.charAt(i))) {
controlCharFound = true;
break;
}
}
if (!controlCharFound) {
return aString;
}
// bad character was found, do another pass and replace all bad
// chars
char[] chars = aString.toCharArray();
for (int i = 0; i < chars.length; i++) {
if (!isValidXmlChar(chars[i])) {
// replace invalid XML char with unicode replacement char
chars[i] = 0xFFFD;
}
}
return new String(chars);
}
private boolean isValidXmlChar(char c) {
return (c >= 0x20 && c < 0xFFFE) || c == 0x09 || c == 0x0A || c == 0x0D;
}
private void addAttribute(AttributesImpl attrs, String attrName, String attrValue) {
// special case: if attrName is "sofaString", we need to check for
// invalid
// XML characters in the data, and replace them
if (CAS.FEATURE_BASE_NAME_SOFASTRING.equals(attrName)) {
attrValue = replaceInvalidXmlChars(attrValue);
}
attrs.addAttribute(null, null, attrName, cdataType, attrValue);
}
private void startElement(String tag, Attributes attrs, int num) throws SAXException {
numChildren = num;
ch.startElement("", "", tag, attrs);
}
private void endElement(String tag) throws SAXException {
ch.endElement("", "", tag);
}
/**
* Encode the indexed FS in the queue.
*
* @throws XMLException
* @throws IOException
* @throws SAXException
*/
private void encodeIndexed() throws IOException, SAXException {
final int max = indexedFSs.size();
for (int i = 0; i < max; i++) {
if (MULTIPLY_INDEXED != queued.get(indexedFSs.get(i))) {
IntVector iv = new IntVector(1);
iv.add(indexReps.get(i));
encodeFS(indexedFSs.get(i), iv);
} else {
int thisDup = duplicates.get(indexedFSs.get(i));
encodeFS(indexedFSs.get(i), (IntVector) dupVectors.get(thisDup));
}
}
}
/**
* Push the indexed FSs onto the queue.
*/
private void enqueueIndexed() {
FSIndexRepositoryImpl ir = (FSIndexRepositoryImpl) cas.getBaseCAS().getBaseIndexRepository();
int[] fsarray = ir.getIndexedFSs();
for (int k = 0; k < fsarray.length; k++) {
enqueueIndexed(fsarray[k], 0);
}
// Get indexes for each SofaFS in the CAS
int numViews = cas.getBaseSofaCount();
for (int sofaNum = 1; sofaNum <= numViews; sofaNum++) {
FSIndexRepositoryImpl loopIR = (FSIndexRepositoryImpl) cas.getBaseCAS()
.getSofaIndexRepository(sofaNum);
if (loopIR != null) {
fsarray = loopIR.getIndexedFSs();
for (int k = 0; k < fsarray.length; k++) {
enqueueIndexed(fsarray[k], sofaNum);
}
}
}
}
private void enqueueFeaturesOfIndexed() {
final int max = indexedFSs.size();
for (int i = 0; i < max; i++) {
int addr = indexedFSs.get(i);
int heapVal = cas.getHeapValue(addr);
final int typeClass = classifyType(heapVal);
if (typeClass == LowLevelCAS.TYPE_CLASS_FS) {
if (mOutOfTypeSystemData != null) {
enqueueOutOfTypeSystemFeatures(addr);
}
enqueueFeatures(addr, heapVal);
} else if (typeClass == LowLevelCAS.TYPE_CLASS_FSARRAY) {
enqueueFSArray(addr);
}
}
}
/**
* Encode all other enqueued (non-indexed) FSs.
*
* @throws XMLException
* @throws IOException
* @throws SAXException
*/
private void encodeQueued() throws IOException, SAXException {
int addr;
while (!queue.empty()) {
addr = queue.pop();
encodeFS(addr, null);
}
}
/**
* Encode an individual FS.
*
* @param addr
* The address to be encoded.
* @param isIndexed
* If the FS is indexed or not.
* @throws XMLException
* @throws IOException
* @throws SAXException
*/
private void encodeFS(int addr, IntVector indexRep) throws IOException, SAXException {
++fsCount;
workAttrs.clear();
// Create an element with the type name as tag.
// xmlStack.pushElementNode(getTypeName(addr));
// Add indexed info.
// if (sofaTypeCode == cas.getHeapValue(addr) &&
// cas.isBackwardCompatibleCas()) {
// // Don't encode sofaFS if old style application
// return;
// }
if (indexRep != null) {
if (indexRep.size() == 1) {
// xmlStack.addAttribute(INDEXED_ATTR_NAME, TRUE_VALUE);
addAttribute(workAttrs, INDEXED_ATTR_NAME, Integer.toString(indexRep.get(0)));
} else {
String multIndex = Integer.toString(indexRep.get(0));
for (int mi = 1; mi < indexRep.size(); mi++) {
multIndex += " " + Integer.toString(indexRep.get(mi));
}
addAttribute(workAttrs, INDEXED_ATTR_NAME, multIndex);
}
}
// Add ID attribute. We do this for every FS, since otherwise we
// would
// have to do a complete traversal of the heap to find out which FSs
// is
// actually referenced.
// xmlStack.addAttribute(ID_ATTR_NAME, Integer.toString(addr));
addAttribute(workAttrs, ID_ATTR_NAME, Integer.toString(addr));
final int typeClass = classifyType(cas.getHeapValue(addr));
// Call special code according to the type of the FS (special
// treatment
// for arrays).
switch (typeClass) {
case LowLevelCAS.TYPE_CLASS_FS: {
String typeName = getTypeName(addr);
encodeFeatures(addr, workAttrs);
if (mOutOfTypeSystemData != null) {
encodeOutOfTypeSystemFeatures(addr, workAttrs); // APL
}
String xcasElementName = getXCasElementName(typeName);
startElement(xcasElementName, workAttrs, 0);
// xmlStack.commitNode();
endElement(xcasElementName);
break;
}
case LowLevelCAS.TYPE_CLASS_INTARRAY: {
IntArrayFSImpl fs = new IntArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
// encodeIntArray(addr, workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_FLOATARRAY: {
FloatArrayFSImpl fs = new FloatArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
// encodeFloatArray(addr, workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_STRINGARRAY: {
StringArrayFSImpl fs = new StringArrayFSImpl(addr, cas);
String[] data = fs.toArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
// encodeStringArray(addr, workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_FSARRAY: {
encodeFSArray(addr, workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_BOOLEANARRAY: {
BooleanArrayFSImpl fs = new BooleanArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_BYTEARRAY: {
ByteArrayFSImpl fs = new ByteArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_SHORTARRAY: {
ShortArrayFSImpl fs = new ShortArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_LONGARRAY: {
LongArrayFSImpl fs = new LongArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
break;
}
case LowLevelCAS.TYPE_CLASS_DOUBLEARRAY: {
DoubleArrayFSImpl fs = new DoubleArrayFSImpl(addr, cas);
String[] data = fs.toStringArray();
encodePrimitiveTypeArrayFS(data, getTypeName(addr), workAttrs);
break;
}
default: {
// Internal error.
System.err.println("Error classifying FS type.");
}
}
// xmlStack.popNode();
}
private void encodePrimitiveTypeArrayFS(String[] data, String typeName, AttributesImpl attrs)
throws SAXException {
addAttribute(attrs, ARRAY_SIZE_ATTR, Integer.toString(data.length));
startElement(typeName, attrs, data.length);
for (int i = 0; i < data.length; i++) {
startElement(ARRAY_ELEMENT_TAG, emptyAttrs, 1);
addText(data[i]);
endElement(ARRAY_ELEMENT_TAG);
}
endElement(typeName);
}
private void encodeFSArray(int addr, AttributesImpl attrs) throws SAXException {
final String typeName = getTypeName(addr);
final int size = cas.ll_getArraySize(addr);
int pos = cas.getArrayStartAddress(addr);
// xmlStack.addAttribute(ARRAY_SIZE_ATTR, Integer.toString(size));
// xmlStack.commitNode();
addAttribute(attrs, ARRAY_SIZE_ATTR, Integer.toString(size));
startElement(typeName, attrs, size);
for (int i = 0; i < size; i++) {
String val = null;
// xmlStack.pushTextNode(ARRAY_ELEMENT_TAG);
// xmlStack.commitNode();
int heapVal = cas.getHeapValue(pos);
if (heapVal == CASImpl.NULL && mOutOfTypeSystemData != null) {
// This array element may have been a reference to an OOTS
// FS.
List ootsElems = (List) mOutOfTypeSystemData.arrayElements.get(new Integer(addr));
if (ootsElems != null) {
Iterator iter = ootsElems.iterator();
while (iter.hasNext()) // TODO: iteration could be slow
// for large arrays
{
ArrayElement ootsElem = (ArrayElement) iter.next();
if (ootsElem.index == i) {
val = (String) mOutOfTypeSystemData.idMap.get(ootsElem.value);
break;
}
}
}
} else if (heapVal != CASImpl.NULL) {
val = Integer.toString(heapVal);
}
if (val != null) {
startElement(ARRAY_ELEMENT_TAG, emptyAttrs, 1);
addText(val);
} else {
startElement(ARRAY_ELEMENT_TAG, emptyAttrs, 0);
}
// xmlStack.popNode();
endElement(ARRAY_ELEMENT_TAG);
++pos;
}
endElement(typeName);
}
private void enqueueFSArray(int addr) {
final int size = cas.ll_getArraySize(addr);
int pos = cas.getArrayStartAddress(addr);
int val;
for (int i = 0; i < size; i++) {
val = cas.getHeapValue(pos);
if (val != CASImpl.NULL) {
enqueue(val);
}
++pos;
}
}
/**
* Encode features of a regular (non-array) FS.
*
* @param addr
*/
private void encodeFeatures(int addr, AttributesImpl attrs) {
int heapValue = cas.getHeapValue(addr);
int[] feats = ts.ll_getAppropriateFeatures(heapValue);
int featAddr, featVal;
String featName, attrValue;
boolean nameMapping = false;
if (sofaTypeCode == heapValue) {
// set flag for SofaID mapping
nameMapping = true;
}
for (int i = 0; i < feats.length; i++) {
featAddr = addr + cas.getFeatureOffset(feats[i]);
featVal = cas.getHeapValue(featAddr);
featName = featureNames[feats[i]];
if (!cas.ll_isRefType(ts.range(feats[i]))) {
attrValue = cas.getFeatureValueAsString(addr, feats[i]);
if (nameMapping && featName.equals(CAS.FEATURE_BASE_NAME_SOFAID) && uimaContext != null) {
// map absolute SofaID to that expected by Component
attrValue = uimaContext.mapSofaIDToComponentSofaName(attrValue);
}
} else {
if (featVal == CASImpl.NULL) {
attrValue = null;
} else {
attrValue = Integer.toString(featVal);
}
}
if (attrValue != null && featName != null) {
addAttribute(attrs, featName, attrValue);
}
}
}
private void enqueueFeatures(int addr, int heapValue) {
int[] feats = ts.ll_getAppropriateFeatures(heapValue);
int featAddr, featVal;
for (int i = 0; i < feats.length; i++) {
featAddr = addr + cas.getFeatureOffset(feats[i]);
featVal = cas.getHeapValue(featAddr);
if (cas.ll_isRefType(ts.range(feats[i]))) {
if (featVal == CASImpl.NULL) {
// break;
} else {
enqueue(featVal);
}
}
}
}
/**
* Encode Out-Of-TypeSystem Features.
*
* @param addr
*/
private void encodeOutOfTypeSystemFeatures(int addr, AttributesImpl attrs) {
List attrList = (List) mOutOfTypeSystemData.extraFeatureValues.get(new Integer(addr));
if (attrList != null) {
Iterator it = attrList.iterator();
while (it.hasNext()) {
String[] attr = (String[]) it.next();
// remap ID if necessary
if (attr[0].startsWith("_ref_")) {
if (attr[1].startsWith("a")) { // reference to OOTS FS
// - remap
attr[1] = (String) mOutOfTypeSystemData.idMap.get(attr[1]);
}
}
addAttribute(attrs, attr[0], attr[1]);
}
}
}
/**
* Encode Out-Of-TypeSystem Features.
*
* @param addr
*/
private void enqueueOutOfTypeSystemFeatures(int addr) {
List attrList = (List) mOutOfTypeSystemData.extraFeatureValues.get(new Integer(addr));
if (attrList != null) {
Iterator it = attrList.iterator();
while (it.hasNext()) {
String[] attr = (String[]) it.next();
// remap ID if necessary
if (attr[0].startsWith("_ref_")) {
// references whose ID starts with the character 'a' are references to out of type
// system FS. All other references should be to in-typesystem FS, which we need to
// enqueue.
if (!attr[1].startsWith("a")) {
enqueue(Integer.parseInt(attr[1]));
}
}
}
}
}
private final String getTypeName(int addr) {
return ts.ll_getTypeForCode(cas.getHeapValue(addr)).getName();
}
private final int classifyType(int type) {
return cas.ll_getTypeClass(type);
}
/**
* Produces XCAS from Out-Of-Typesystem data. (APL)
*/
private void enqueueOutOfTypeSystemData(OutOfTypeSystemData aData) {
Iterator it = aData.fsList.iterator();
while (it.hasNext()) {
FSData fs = (FSData) it.next();
Iterator attrIt = fs.featVals.entrySet().iterator();
while (attrIt.hasNext()) {
Map.Entry entry = (Map.Entry) attrIt.next();
String attrName = (String) entry.getKey();
if (attrName.startsWith("_ref_")) {
String attrVal = (String) entry.getValue();
// references whose ID starts with the character 'a' are references to out of type
// system FS. All other references should be to in-typesystem FS, which we need to
// enqueue.
if (!attrVal.startsWith("a")) {
enqueue(Integer.parseInt(attrVal));
}
}
}
}
}
private void serializeOutOfTypeSystemData(OutOfTypeSystemData aData) throws SAXException {
Iterator it = aData.fsList.iterator();
while (it.hasNext()) {
FSData fs = (FSData) it.next();
workAttrs.clear();
// Add indexed info.
if (fs.indexRep != null) {
// xmlStack.addAttribute(INDEXED_ATTR_NAME, TRUE_VALUE);
addAttribute(workAttrs, INDEXED_ATTR_NAME, fs.indexRep);
}
// Add ID attribute (remap to new unique integer ID).
addAttribute(workAttrs, ID_ATTR_NAME, fs.id);
// Add other attributes (remap OOTS refs)
Iterator attrIt = fs.featVals.entrySet().iterator();
while (attrIt.hasNext()) {
Map.Entry entry = (Map.Entry) attrIt.next();
String attrName = (String) entry.getKey();
String attrVal = (String) entry.getValue();
if (attrName.startsWith("_ref_")) {
if (attrVal.startsWith("a")) {
// "a" prefix indicates a reference from one OOTS FS
// to another OOTS FS;
// we need to remap those IDs to the actual IDs used
// in the XCAS
attrVal = (String) mOutOfTypeSystemData.idMap.get(attrVal);
}
}
addAttribute(workAttrs, attrName, attrVal);
}
// send events
String xcasElementName = getXCasElementName(fs.type);
startElement(xcasElementName, workAttrs, 0);
endElement(xcasElementName);
}
}
}
/**
* Gets the XCAS element name for a CAS type name. The element name is usually the same as the
* type name, but the sequences _colon_ and _dash_ are translated to the characters : and -,
* respectively.
*
* @param aCasTypeName
* CAS type name
* @return XCAS element name for this type name
*/
private String getXCasElementName(String aTagName) {
if (aTagName.indexOf(':') == -1 && aTagName.indexOf('-') == -1) {
return aTagName;
} else {
// Note: This is really slow so we avoid if possible. -- RJB
return StringUtils
.replaceAll(StringUtils.replaceAll(aTagName, ":", "_colon_"), "-", "_dash_");
}
}
public static final String casTagName = "CAS";
public static final String VERSION_ATTR = "version";
public static final String CURRENT_VERSION = "2";
public static final String DEFAULT_DOC_TYPE_NAME = "uima.tcas.Document";
public static final String DEFAULT_DOC_TEXT_FEAT = "text";
public static final String INDEXED_ATTR_NAME = "_indexed";
public static final String REF_PREFIX = "_ref_";
public static final String ID_ATTR_NAME = "_id";
public static final String CONTENT_ATTR_NAME = "_content";
public static final String ARRAY_SIZE_ATTR = "size";
public static final String ARRAY_ELEMENT_TAG = "i";
public static final String TRUE_VALUE = "true";
private TypeSystemImpl ts;
private UimaContext uimaContext;
// Create own cache of feature names because of _ref_ prefixes.
private String[] featureNames;
// name of tag to contain document text
private String docTypeName = DEFAULT_DOC_TYPE_NAME;
// value of _content attribute for document text element
private String docTextFeature = DEFAULT_DOC_TEXT_FEAT;
public XCASSerializer(TypeSystem ts, UimaContext uimaContext) {
super();
// System.out.println("Creating serializer for type system.");
this.ts = (TypeSystemImpl) ts;
this.uimaContext = uimaContext;
// Create feature name cache.
final int featArraySize = this.ts.getNumberOfFeatures() + 1;
this.featureNames = new String[featArraySize];
FeatureImpl feat;
String featName;
Iterator it = this.ts.getFeatures();
while (it.hasNext()) {
feat = (FeatureImpl) it.next();
if (feat.getRange().isPrimitive()) {
featName = feat.getShortName();
} else {
featName = REF_PREFIX + feat.getShortName();
}
this.featureNames[feat.getCode()] = featName;
}
}
public XCASSerializer(TypeSystem ts) {
this(ts, null);
}
/**
* Write the CAS data to a SAX content handler.
*
* @param cas
* The CAS to be serialized.
* @param contentHandler
* The SAX content handler the data is written to.
* @throws IOException
* @throws SAXException
*/
public void serialize(CAS cas, ContentHandler contentHandler) throws IOException, SAXException {
serialize(cas, contentHandler, true);
}
/**
* Write the CAS data to a SAX content handler.
*
* @param cas
* The CAS to be serialized.
* @param contentHandler
* The SAX content handler the data is written to.
* @param encodeDoc
* If set to false, no uima.tcas.Document structure will be created, and the document
* text will not be serialized.
* @throws IOException
* @throws SAXException
*/
public void serialize(CAS cas, ContentHandler contentHandler, boolean encodeDoc)
throws IOException, SAXException {
serialize(cas, contentHandler, encodeDoc, null);
}
/**
* Write the CAS data to a SAX content handler.
*
* @param cas
* The CAS to be serialized.
* @param contentHandler
* The SAX content handler the data is written to.
* @param encodeDoc
* If set to false, no uima.tcas.Document structure will be created, and the document
* text will not be serialized.
* @param outOfTypeSystemData
* data not part of the CAS type system, which should be inserted into the XCAS output
*
* @throws IOException
* @throws SAXException
*/
public void serialize(CAS cas, ContentHandler contentHandler, boolean encodeDoc,
OutOfTypeSystemData outOfTypeSystemData) throws IOException, SAXException {
contentHandler.startDocument();
XCASDocSerializer ser = new XCASDocSerializer(contentHandler, ((CASImpl) cas).getBaseCAS());
ser.serialize(encodeDoc, outOfTypeSystemData);
contentHandler.endDocument();
// System.out.println("Done serializing " + ser.fsCount + " FSs.");
}
/**
* Gets the name of the type representing the document. This will become the name of the XML
* element that will hold the document text.
*
* @return the document type name
*/
public String getDocumentTypeName() {
return docTypeName;
}
/**
* Gets the name of the type representing the document. This will become the name of the XML
* element that will hold the document text. If not set, defaults to
* {@link #DEFAULT_DOC_TYPE_NAME}.
*
* @param aDocTypeName
* the document type name
*/
public void setDocumentTypeName(String aDocTypeName) {
docTypeName = aDocTypeName;
}
/**
* Gets the name of the feature holding the documeng text. This will become the value of the
* _content attribute on the document element.
*
* @return the document text feature
*/
public String getDocumentTextFeature() {
return docTextFeature;
}
/**
* Sets the name of the feature holding the documeng text. This will become the value of the
* _content attribute on the document element. If not set, defaults to
* {@link #DEFAULT_DOC_TEXT_FEAT}. If set to null, no _content attribute will be emitted.
*
* @param aDocTextFeature
* the document text feature
*/
public void setDocumentTextFeature(String aDocTextFeature) {
docTextFeature = aDocTextFeature;
}
/**
* Serializes an XCAS to a stream.
*
* @param aCAS
* CAS to serialize.
* @param aStream
* output stream to which to write the XCAS XML document
*
* @throws SAXException
* if a problem occurs during XCAS serialization
* @throws IOException
* if an I/O failure occurs
*/
public static void serialize(CAS aCAS, OutputStream aStream) throws SAXException, IOException {
XCASSerializer.serialize(aCAS, aStream, false);
}
/**
* Serializes an XCAS to a stream.
*
* @param aCAS
* CAS to serialize.
* @param aStream
* output stream to which to write the XCAS XML document
* @param isFormattedOutput
* if true the XCAS will be serialized formatted
*
* @throws SAXException
* if a problem occurs during XCAS serialization
* @throws IOException
* if an I/O failure occurs
*/
public static void serialize(CAS aCAS, OutputStream aStream, boolean isFormattedOutput)
throws SAXException, IOException {
XCASSerializer xcasSerializer = new XCASSerializer(aCAS.getTypeSystem());
XMLSerializer sax2xml = new XMLSerializer(aStream, isFormattedOutput);
xcasSerializer.serialize(aCAS, sax2xml.getContentHandler());
}
}