uimaj-2.3.0-incubating/uimaj-core/src/main/java/org/apache/uima/cas_data/impl/XCasToCasDataSaxHandler.java - uima-uimaj - Git at Google

 /*
  * 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_data.impl;

 import org.apache.uima.cas.CAS;
 import org.apache.uima.cas.impl.XCASParsingException;
 import org.apache.uima.cas.impl.XCASSerializer;
 import org.apache.uima.cas_data.CasData;
 import org.apache.uima.cas_data.PrimitiveArrayFS;
 import org.apache.uima.cas_data.ReferenceArrayFS;
 import org.apache.uima.internal.util.StringUtils;
 import org.xml.sax.Attributes;
 import org.xml.sax.Locator;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 import org.xml.sax.helpers.DefaultHandler;

 /**
  * A SAX ContentHandler that reads XCAS and creates a CasData.
  *
  *
  */
 public class XCasToCasDataSaxHandler extends DefaultHandler {
   // ///////////////////////////////////////////////////////////////////////
   // Internal states for the parser.

   // Expect the start of the XML document.
   private static final int DOC_STATE = 0;

   // At the top level. Expect a FS.
   private static final int FS_STATE = 1;

   // Inside a FS. Expect features, or the end of the FS.
   private static final int FEAT_STATE = 2;

   // Inside FS. We have seen a _content attribute, and expect text.
   private static final int CONTENT_STATE = 3;

   // Inside a feature element. We expect the feature value.
   private static final int FEAT_CONTENT_STATE = 4;

   // Inside an array element. Expect array element value.
   private static final int ARRAY_ELE_CONTENT_STATE = 5;

   // Inside an array FS. Expect an array element, or the end of the FS.
   private static final int ARRAY_ELE_STATE = 6;

   // End parser states.
   // ///////////////////////////////////////////////////////////////////////

   private static final String reservedAttrPrefix = "_";

   // For error message printing, if the Locator object can't provide source
   // of XML input.
   private static final String unknownXMLSource = "<unknown>";

   private static final String DEFAULT_CONTENT_FEATURE = "value";

   // private long time;

   // SAX locator. Used for error message generation.
   private Locator locator;

   // The CasData we're filling.
   private CasData cas;

   // What we expect next.
   private int state;

   // StringBuffer to accumulate text.
   private StringBuffer buffer;

   // Most recently created FS. Needed for array elements
   // and embedded feature values.
   private FeatureStructureImpl currentFS;

   // The name of the content feature, if we've seen one.
   private String currentContentFeat;

   // The current position when parsing array elements.
   private int arrayPos;

   // The type of the array we're currently reading. Needed for proper
   // treatment of array element values.
   private int arrayType;

   /**
    * Create new XCasToCasDataSaxHandler.
    *
    * @param aCasData
    *          the CasData to which FeatureStructures parsed from XCAS will be appended
    */
   public XCasToCasDataSaxHandler(CasData aCasData) {
     super();
     this.buffer = new StringBuffer();
     this.cas = aCasData;
   }

   private final void resetBuffer() {
     // this.buffer.delete(0, this.buffer.length());
     this.buffer = new StringBuffer();
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#startDocument()
    */
   public void startDocument() throws SAXException {
     // Do setup work in the constructor.
     this.state = DOC_STATE;
     // System.out.println("Starting to read document.");
     // time = System.currentTimeMillis();
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#startElement(java.lang.String, java.lang.String,
    *      java.lang.String, org.xml.sax.Attributes)
    */
   public void startElement(String nameSpaceURI, String localName, String qualifiedName,
           Attributes attrs) throws SAXException {
     resetBuffer();
     switch (state) {
       case DOC_STATE: {
         if (!qualifiedName.equals(XCASSerializer.casTagName)) {
           throw createException(XCASParsingException.WRONG_ROOT_TAG, qualifiedName);
         }
         this.state = FS_STATE;
         break;
       }
       case FS_STATE: {
         this.currentContentFeat = DEFAULT_CONTENT_FEATURE;
         readFS(qualifiedName, attrs);
         break;
       }
       case ARRAY_ELE_STATE: {
         readArrayElement(qualifiedName, attrs);
         break;
       }
       default: {
         // If we're not in an element expecting state, raise an error.
         throw createException(XCASParsingException.TEXT_EXPECTED, qualifiedName);
       }
     }
   }

   // Get ready to read array element.
   private void readArrayElement(String eleName, Attributes attrs) throws SAXParseException {
     if (!eleName.equals(XCASSerializer.ARRAY_ELEMENT_TAG)) {
       throw createException(XCASParsingException.ARRAY_ELE_EXPECTED, eleName);
     }
     if (attrs.getLength() > 0) {
       throw createException(XCASParsingException.ARRAY_ELE_ATTRS);
     }
     this.state = ARRAY_ELE_CONTENT_STATE;
     resetBuffer();
   }

   // Create a new FS.
   private void readFS(String qualifiedName, Attributes attrs) throws SAXParseException {
     if (isArrayType(qualifiedName)) {
       readArray(qualifiedName, attrs);
     } else {
       this.currentFS = new FeatureStructureImpl();
       this.currentFS.setType(getCasTypeName(qualifiedName));
       readFS(this.currentFS, attrs);
     }
     this.cas.addFeatureStructure(this.currentFS);
   }

   /**
    * Gets the CAS type name corresponding to an XCAS tag name. The type name is usually equal to the
    * tag name, but the characters : and - are translated into the sequences _colon_ and _dash_,
    * respectively.
    *
    * @param aTagName
    *          XCAS tag name
    * @return CAS type name corresponding to this tag
    */
   private String getCasTypeName(String aTagName) {
     return StringUtils.replaceAll(StringUtils.replaceAll(aTagName, ":", "_colon_"), "-", "_dash_");
   }

   /**
    *
    * @param addr
    * @param attrs
    * @throws SAXParseException
    */
   private void readFS(FeatureStructureImpl fsImpl, Attributes attrs) throws SAXParseException {
     String attrName, attrValue;
     for (int i = 0; i < attrs.getLength(); i++) {
       attrName = attrs.getQName(i);
       attrValue = attrs.getValue(i);
       if (attrName.startsWith(reservedAttrPrefix)) {
         if (attrName.equals(XCASSerializer.ID_ATTR_NAME)) {
           fsImpl.setId(attrValue);
         } else if (attrName.equals(XCASSerializer.CONTENT_ATTR_NAME)) {
           this.currentContentFeat = attrValue;
         } else if (attrName.equals(XCASSerializer.INDEXED_ATTR_NAME)) {
           if (attrValue.equals(XCASSerializer.TRUE_VALUE)) {
             fsImpl.setIndexed(new int[] { 1 }); // Backwards compatible CAS, has one default text
             // Sofa
           } else if (!attrValue.equals("false")) {
             fsImpl.setIndexed(parseIntArray(attrValue));
           }
         } else {
           handleFeature(fsImpl, attrName, attrValue);
         }
       } else {
         handleFeature(fsImpl, attrName, attrValue);
       }
     }

     // Set the state; we're either expecting features, or _content.
     // APL - 6/28/04 - even if _content attr is not specified, we can still have content, which
     // would
     // be assigned to the "value" feature, as per XCAS spec. FEAT_STATE did not really seem to be
     // working, anyway.
     this.state = CONTENT_STATE;
     // if (this.state != CONTENT_STATE)
     // {
     // this.state = FEAT_STATE;
     // }
   }

   /**
    * Parse a space-separated string into an integer array.
    */
   private int[] parseIntArray(String val) {
     String[] strVals;
     val = val.trim();
     if ("".equals(val)) {
       strVals = new String[0];
     } else {
       strVals = val.split("\\s+");
     }
     int[] intVals = new int[strVals.length];
     for (int i = 0; i < strVals.length; i++) {
       intVals[i] = Integer.parseInt(strVals[i]);
     }
     return intVals;
   }

   // Create a new array FS.
   private void readArray(String type, Attributes attrs) throws SAXParseException {
     String attrName, attrVal;
     int[] indexed = new int[0];
     int size = 0;
     String id = null;
     for (int i = 0; i < attrs.getLength(); i++) {
       attrName = attrs.getQName(i);
       attrVal = attrs.getValue(i);
       if (attrName.equals(XCASSerializer.ID_ATTR_NAME)) {
         id = attrVal;
       } else if (attrName.equals(XCASSerializer.ARRAY_SIZE_ATTR)) {
         try {
           size = Integer.parseInt(attrVal);
           if (size < 0) {
             throw createException(XCASParsingException.ILLEGAL_ARRAY_SIZE, attrVal);
           }
         } catch (NumberFormatException e) {
           throw createException(XCASParsingException.INTEGER_EXPECTED, attrVal);
         }
       } else if (attrName.equals(XCASSerializer.INDEXED_ATTR_NAME)) {
         if (attrVal.equals(XCASSerializer.TRUE_VALUE)) {
           indexed = new int[] { 1 }; // Backwards compatible CAS, has one default text Sofa
         } else if (!attrVal.equals("false")) {
           indexed = parseIntArray(attrVal);
         }
       } else {
         throw createException(XCASParsingException.ILLEGAL_ARRAY_ATTR, attrName);
       }
     }
     // Hang on to those for setting array values.
     this.arrayPos = 0;
     if (CAS.TYPE_NAME_INTEGER_ARRAY.equals(type)) {
       this.currentFS = new PrimitiveArrayFSImpl(new int[size]);
       this.arrayType = INT_TYPE;
     } else if (CAS.TYPE_NAME_FLOAT_ARRAY.equals(type)) {
       this.currentFS = new PrimitiveArrayFSImpl(new float[size]);
       this.arrayType = FLOAT_TYPE;
     } else if (CAS.TYPE_NAME_STRING_ARRAY.equals(type)) {
       this.currentFS = new PrimitiveArrayFSImpl(new String[size]);
       this.arrayType = STRING_TYPE;
     } else {
       this.currentFS = new ReferenceArrayFSImpl(new String[size]);
       this.arrayType = FS_TYPE;
     }
     this.currentFS.setId(id);
     this.currentFS.setType(type);
     this.currentFS.setIndexed(indexed);
     this.currentFS.setFeatureValue(XCASSerializer.ARRAY_SIZE_ATTR, new PrimitiveValueImpl(size));
     this.state = ARRAY_ELE_STATE;
   }

   // The definition of a null value. Any other value must be in the expected
   // format.
   private final boolean emptyVal(String val) {
     return ((val == null) || (val.length() == 0));
   }

   // Create a feature value from a string representation.
   private void handleFeature(FeatureStructureImpl fsImpl, String featName, String featVal)
           throws SAXParseException {
     if (featName.startsWith(XCASSerializer.REF_PREFIX)) {
       String realFeatName = featName.substring(XCASSerializer.REF_PREFIX.length());
       fsImpl.setFeatureValue(realFeatName, new ReferenceValueImpl(featVal));
     } else {
       fsImpl.setFeatureValue(featName, new PrimitiveValueImpl(featVal));
     }
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#characters(char[], int, int)
    */
   public void characters(char[] chars, int start, int length) throws SAXException {
     if ((this.state == CONTENT_STATE)
             || (this.state == ARRAY_ELE_CONTENT_STATE) || (this.state == FEAT_CONTENT_STATE)) {
       // When we're in a text expecting state, add the characters to the
       // text buffer. Else, do nothing.
       buffer.append(chars, start, length);
     }
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#endElement(java.lang.String, java.lang.String,
    *      java.lang.String)
    */
   public void endElement(String nsURI, String localName, String qualifiedName) throws SAXException {
     switch (this.state) {
       case DOC_STATE: {
         // Do nothing.
         break;
       }
       case FS_STATE: {
         this.state = DOC_STATE;
         break;
       }
       case FEAT_STATE: {
         this.state = FS_STATE;
         break;
       }
       case CONTENT_STATE: {
         if (!isAllWhitespace(buffer)) {
           // Set the value of the content feature.
           handleFeature(this.currentFS, currentContentFeat, buffer.toString());
         }
         this.state = FS_STATE;
         break;
       }
       case FEAT_CONTENT_STATE: {
         // Create a feature value from an element.
         handleFeature(this.currentFS, qualifiedName, buffer.toString());
         this.state = FEAT_STATE;
         break;
       }
       case ARRAY_ELE_CONTENT_STATE: {
         // Create an array value.
         addArrayElement(buffer.toString());
         this.state = ARRAY_ELE_STATE;
         break;
       }
       case ARRAY_ELE_STATE: {
         this.state = FS_STATE;
         break;
       }
     }
   }

   boolean isAllWhitespace(StringBuffer b) {
     final int len = b.length();
     for (int i = 0; i < len; i++) {
       if (!Character.isWhitespace(b.charAt(i))) {
         return false;
       }
     }
     return true;
   }

   private void addArrayElement(String content) throws SAXParseException {
     switch (arrayType) {
       case INT_TYPE: {
         if (!emptyVal(content)) {
           try {
             ((PrimitiveArrayFS) this.currentFS).toIntArray()[arrayPos] = Integer.parseInt(content);
           } catch (NumberFormatException e) {
             throw createException(XCASParsingException.INTEGER_EXPECTED, content);
           }
         }
         break;
       }
       case FLOAT_TYPE: {
         if (!emptyVal(content)) {
           try {
             ((PrimitiveArrayFS) this.currentFS).toFloatArray()[arrayPos] = Float
                     .parseFloat(content);
           } catch (NumberFormatException e) {
             throw createException(XCASParsingException.FLOAT_EXPECTED, content);
           }
         }
         break;
       }
       case STRING_TYPE: {
         ((PrimitiveArrayFS) this.currentFS).toStringArray()[arrayPos] = content;
         break;
       }
       case FS_TYPE: {
         if (!emptyVal(content)) {
           ((ReferenceArrayFS) this.currentFS).getIdRefArray()[arrayPos] = content;
         }
         break;
       }
     }
     ++arrayPos;
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#endDocument()
    */
   public void endDocument() throws SAXException {
     // nothing to do
   }

   private XCASParsingException createException(int code) {
     XCASParsingException e = new XCASParsingException(code);
     String source = unknownXMLSource;
     String line = unknownXMLSource;
     String col = unknownXMLSource;
     if (locator != null) {
       source = locator.getSystemId();
       if (source == null) {
         source = locator.getPublicId();
       }
       if (source == null) {
         source = unknownXMLSource;
       }
       line = Integer.toString(locator.getLineNumber());
       col = Integer.toString(locator.getColumnNumber());
     }
     e.addArgument(source);
     e.addArgument(line);
     e.addArgument(col);
     return e;
   }

   private XCASParsingException createException(int code, String arg) {
     XCASParsingException e = createException(code);
     e.addArgument(arg);
     return e;
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ErrorHandler#error(org.xml.sax.SAXParseException)
    */
   public void error(SAXParseException e) throws SAXException {
     throw e;
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ErrorHandler#fatalError(org.xml.sax.SAXParseException)
    */
   public void fatalError(SAXParseException e) throws SAXException {
     throw e;
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int)
    */
   public void ignorableWhitespace(char[] arg0, int arg1, int arg2) throws SAXException {
     // Since we're not validating, we don't need to do anything; this won't
     // be called.
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ContentHandler#setDocumentLocator(org.xml.sax.Locator)
    */
   public void setDocumentLocator(Locator loc) {
     // System.out.println("Setting document locator.");
     this.locator = loc;
   }

   /*
    * (non-Javadoc)
    *
    * @see org.xml.sax.ErrorHandler#warning(org.xml.sax.SAXParseException)
    */
   public void warning(SAXParseException e) throws SAXException {
     throw e;
   }

   private static final int INT_TYPE = 0;

   private static final int FLOAT_TYPE = 1;

   private static final int STRING_TYPE = 2;

   private static final int FS_TYPE = 3;

   private boolean isArrayType(String typeName) {
     return CAS.TYPE_NAME_INTEGER_ARRAY.equals(typeName)
             || CAS.TYPE_NAME_FLOAT_ARRAY.equals(typeName)
             || CAS.TYPE_NAME_STRING_ARRAY.equals(typeName)
             || CAS.TYPE_NAME_FS_ARRAY.equals(typeName);
   }

 }
	/*
	* 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_data.impl;

	import org.apache.uima.cas.CAS;
	import org.apache.uima.cas.impl.XCASParsingException;
	import org.apache.uima.cas.impl.XCASSerializer;
	import org.apache.uima.cas_data.CasData;
	import org.apache.uima.cas_data.PrimitiveArrayFS;
	import org.apache.uima.cas_data.ReferenceArrayFS;
	import org.apache.uima.internal.util.StringUtils;
	import org.xml.sax.Attributes;
	import org.xml.sax.Locator;
	import org.xml.sax.SAXException;
	import org.xml.sax.SAXParseException;
	import org.xml.sax.helpers.DefaultHandler;

	/**
	* A SAX ContentHandler that reads XCAS and creates a CasData.
	*
	*
	*/
	public class XCasToCasDataSaxHandler extends DefaultHandler {
	// ///////////////////////////////////////////////////////////////////////
	// Internal states for the parser.

	// Expect the start of the XML document.
	private static final int DOC_STATE = 0;

	// At the top level. Expect a FS.
	private static final int FS_STATE = 1;

	// Inside a FS. Expect features, or the end of the FS.
	private static final int FEAT_STATE = 2;

	// Inside FS. We have seen a _content attribute, and expect text.
	private static final int CONTENT_STATE = 3;

	// Inside a feature element. We expect the feature value.
	private static final int FEAT_CONTENT_STATE = 4;

	// Inside an array element. Expect array element value.
	private static final int ARRAY_ELE_CONTENT_STATE = 5;

	// Inside an array FS. Expect an array element, or the end of the FS.
	private static final int ARRAY_ELE_STATE = 6;

	// End parser states.
	// ///////////////////////////////////////////////////////////////////////

	private static final String reservedAttrPrefix = "_";

	// For error message printing, if the Locator object can't provide source
	// of XML input.
	private static final String unknownXMLSource = "<unknown>";

	private static final String DEFAULT_CONTENT_FEATURE = "value";

	// private long time;

	// SAX locator. Used for error message generation.
	private Locator locator;

	// The CasData we're filling.
	private CasData cas;

	// What we expect next.
	private int state;

	// StringBuffer to accumulate text.
	private StringBuffer buffer;

	// Most recently created FS. Needed for array elements
	// and embedded feature values.
	private FeatureStructureImpl currentFS;

	// The name of the content feature, if we've seen one.
	private String currentContentFeat;

	// The current position when parsing array elements.
	private int arrayPos;

	// The type of the array we're currently reading. Needed for proper
	// treatment of array element values.
	private int arrayType;

	/**
	* Create new XCasToCasDataSaxHandler.
	*
	* @param aCasData
	* the CasData to which FeatureStructures parsed from XCAS will be appended
	*/
	public XCasToCasDataSaxHandler(CasData aCasData) {
	super();
	this.buffer = new StringBuffer();
	this.cas = aCasData;
	}

	private final void resetBuffer() {
	// this.buffer.delete(0, this.buffer.length());
	this.buffer = new StringBuffer();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#startDocument()
	*/
	public void startDocument() throws SAXException {
	// Do setup work in the constructor.
	this.state = DOC_STATE;
	// System.out.println("Starting to read document.");
	// time = System.currentTimeMillis();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#startElement(java.lang.String, java.lang.String,
	* java.lang.String, org.xml.sax.Attributes)
	*/
	public void startElement(String nameSpaceURI, String localName, String qualifiedName,
	Attributes attrs) throws SAXException {
	resetBuffer();
	switch (state) {
	case DOC_STATE: {
	if (!qualifiedName.equals(XCASSerializer.casTagName)) {
	throw createException(XCASParsingException.WRONG_ROOT_TAG, qualifiedName);
	}
	this.state = FS_STATE;
	break;
	}
	case FS_STATE: {
	this.currentContentFeat = DEFAULT_CONTENT_FEATURE;
	readFS(qualifiedName, attrs);
	break;
	}
	case ARRAY_ELE_STATE: {
	readArrayElement(qualifiedName, attrs);
	break;
	}
	default: {
	// If we're not in an element expecting state, raise an error.
	throw createException(XCASParsingException.TEXT_EXPECTED, qualifiedName);
	}
	}
	}

	// Get ready to read array element.
	private void readArrayElement(String eleName, Attributes attrs) throws SAXParseException {
	if (!eleName.equals(XCASSerializer.ARRAY_ELEMENT_TAG)) {
	throw createException(XCASParsingException.ARRAY_ELE_EXPECTED, eleName);
	}
	if (attrs.getLength() > 0) {
	throw createException(XCASParsingException.ARRAY_ELE_ATTRS);
	}
	this.state = ARRAY_ELE_CONTENT_STATE;
	resetBuffer();
	}

	// Create a new FS.
	private void readFS(String qualifiedName, Attributes attrs) throws SAXParseException {
	if (isArrayType(qualifiedName)) {
	readArray(qualifiedName, attrs);
	} else {
	this.currentFS = new FeatureStructureImpl();
	this.currentFS.setType(getCasTypeName(qualifiedName));
	readFS(this.currentFS, attrs);
	}
	this.cas.addFeatureStructure(this.currentFS);
	}

	/**
	* Gets the CAS type name corresponding to an XCAS tag name. The type name is usually equal to the
	* tag name, but the characters : and - are translated into the sequences _colon_ and _dash_,
	* respectively.
	*
	* @param aTagName
	* XCAS tag name
	* @return CAS type name corresponding to this tag
	*/
	private String getCasTypeName(String aTagName) {
	return StringUtils.replaceAll(StringUtils.replaceAll(aTagName, ":", "_colon_"), "-", "_dash_");
	}

	/**
	*
	* @param addr
	* @param attrs
	* @throws SAXParseException
	*/
	private void readFS(FeatureStructureImpl fsImpl, Attributes attrs) throws SAXParseException {
	String attrName, attrValue;
	for (int i = 0; i < attrs.getLength(); i++) {
	attrName = attrs.getQName(i);
	attrValue = attrs.getValue(i);
	if (attrName.startsWith(reservedAttrPrefix)) {
	if (attrName.equals(XCASSerializer.ID_ATTR_NAME)) {
	fsImpl.setId(attrValue);
	} else if (attrName.equals(XCASSerializer.CONTENT_ATTR_NAME)) {
	this.currentContentFeat = attrValue;
	} else if (attrName.equals(XCASSerializer.INDEXED_ATTR_NAME)) {
	if (attrValue.equals(XCASSerializer.TRUE_VALUE)) {
	fsImpl.setIndexed(new int[] { 1 }); // Backwards compatible CAS, has one default text
	// Sofa
	} else if (!attrValue.equals("false")) {
	fsImpl.setIndexed(parseIntArray(attrValue));
	}
	} else {
	handleFeature(fsImpl, attrName, attrValue);
	}
	} else {
	handleFeature(fsImpl, attrName, attrValue);
	}
	}

	// Set the state; we're either expecting features, or _content.
	// APL - 6/28/04 - even if _content attr is not specified, we can still have content, which
	// would
	// be assigned to the "value" feature, as per XCAS spec. FEAT_STATE did not really seem to be
	// working, anyway.
	this.state = CONTENT_STATE;
	// if (this.state != CONTENT_STATE)
	// {
	// this.state = FEAT_STATE;
	// }
	}

	/**
	* Parse a space-separated string into an integer array.
	*/
	private int[] parseIntArray(String val) {
	String[] strVals;
	val = val.trim();
	if ("".equals(val)) {
	strVals = new String[0];
	} else {
	strVals = val.split("\\s+");
	}
	int[] intVals = new int[strVals.length];
	for (int i = 0; i < strVals.length; i++) {
	intVals[i] = Integer.parseInt(strVals[i]);
	}
	return intVals;
	}

	// Create a new array FS.
	private void readArray(String type, Attributes attrs) throws SAXParseException {
	String attrName, attrVal;
	int[] indexed = new int[0];
	int size = 0;
	String id = null;
	for (int i = 0; i < attrs.getLength(); i++) {
	attrName = attrs.getQName(i);
	attrVal = attrs.getValue(i);
	if (attrName.equals(XCASSerializer.ID_ATTR_NAME)) {
	id = attrVal;
	} else if (attrName.equals(XCASSerializer.ARRAY_SIZE_ATTR)) {
	try {
	size = Integer.parseInt(attrVal);
	if (size < 0) {
	throw createException(XCASParsingException.ILLEGAL_ARRAY_SIZE, attrVal);
	}
	} catch (NumberFormatException e) {
	throw createException(XCASParsingException.INTEGER_EXPECTED, attrVal);
	}
	} else if (attrName.equals(XCASSerializer.INDEXED_ATTR_NAME)) {
	if (attrVal.equals(XCASSerializer.TRUE_VALUE)) {
	indexed = new int[] { 1 }; // Backwards compatible CAS, has one default text Sofa
	} else if (!attrVal.equals("false")) {
	indexed = parseIntArray(attrVal);
	}
	} else {
	throw createException(XCASParsingException.ILLEGAL_ARRAY_ATTR, attrName);
	}
	}
	// Hang on to those for setting array values.
	this.arrayPos = 0;
	if (CAS.TYPE_NAME_INTEGER_ARRAY.equals(type)) {
	this.currentFS = new PrimitiveArrayFSImpl(new int[size]);
	this.arrayType = INT_TYPE;
	} else if (CAS.TYPE_NAME_FLOAT_ARRAY.equals(type)) {
	this.currentFS = new PrimitiveArrayFSImpl(new float[size]);
	this.arrayType = FLOAT_TYPE;
	} else if (CAS.TYPE_NAME_STRING_ARRAY.equals(type)) {
	this.currentFS = new PrimitiveArrayFSImpl(new String[size]);
	this.arrayType = STRING_TYPE;
	} else {
	this.currentFS = new ReferenceArrayFSImpl(new String[size]);
	this.arrayType = FS_TYPE;
	}
	this.currentFS.setId(id);
	this.currentFS.setType(type);
	this.currentFS.setIndexed(indexed);
	this.currentFS.setFeatureValue(XCASSerializer.ARRAY_SIZE_ATTR, new PrimitiveValueImpl(size));
	this.state = ARRAY_ELE_STATE;
	}

	// The definition of a null value. Any other value must be in the expected
	// format.
	private final boolean emptyVal(String val) {
	return ((val == null) \|\| (val.length() == 0));
	}

	// Create a feature value from a string representation.
	private void handleFeature(FeatureStructureImpl fsImpl, String featName, String featVal)
	throws SAXParseException {
	if (featName.startsWith(XCASSerializer.REF_PREFIX)) {
	String realFeatName = featName.substring(XCASSerializer.REF_PREFIX.length());
	fsImpl.setFeatureValue(realFeatName, new ReferenceValueImpl(featVal));
	} else {
	fsImpl.setFeatureValue(featName, new PrimitiveValueImpl(featVal));
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#characters(char[], int, int)
	*/
	public void characters(char[] chars, int start, int length) throws SAXException {
	if ((this.state == CONTENT_STATE)
	\|\| (this.state == ARRAY_ELE_CONTENT_STATE) \|\| (this.state == FEAT_CONTENT_STATE)) {
	// When we're in a text expecting state, add the characters to the
	// text buffer. Else, do nothing.
	buffer.append(chars, start, length);
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#endElement(java.lang.String, java.lang.String,
	* java.lang.String)
	*/
	public void endElement(String nsURI, String localName, String qualifiedName) throws SAXException {
	switch (this.state) {
	case DOC_STATE: {
	// Do nothing.
	break;
	}
	case FS_STATE: {
	this.state = DOC_STATE;
	break;
	}
	case FEAT_STATE: {
	this.state = FS_STATE;
	break;
	}
	case CONTENT_STATE: {
	if (!isAllWhitespace(buffer)) {
	// Set the value of the content feature.
	handleFeature(this.currentFS, currentContentFeat, buffer.toString());
	}
	this.state = FS_STATE;
	break;
	}
	case FEAT_CONTENT_STATE: {
	// Create a feature value from an element.
	handleFeature(this.currentFS, qualifiedName, buffer.toString());
	this.state = FEAT_STATE;
	break;
	}
	case ARRAY_ELE_CONTENT_STATE: {
	// Create an array value.
	addArrayElement(buffer.toString());
	this.state = ARRAY_ELE_STATE;
	break;
	}
	case ARRAY_ELE_STATE: {
	this.state = FS_STATE;
	break;
	}
	}
	}

	boolean isAllWhitespace(StringBuffer b) {
	final int len = b.length();
	for (int i = 0; i < len; i++) {
	if (!Character.isWhitespace(b.charAt(i))) {
	return false;
	}
	}
	return true;
	}

	private void addArrayElement(String content) throws SAXParseException {
	switch (arrayType) {
	case INT_TYPE: {
	if (!emptyVal(content)) {
	try {
	((PrimitiveArrayFS) this.currentFS).toIntArray()[arrayPos] = Integer.parseInt(content);
	} catch (NumberFormatException e) {
	throw createException(XCASParsingException.INTEGER_EXPECTED, content);
	}
	}
	break;
	}
	case FLOAT_TYPE: {
	if (!emptyVal(content)) {
	try {
	((PrimitiveArrayFS) this.currentFS).toFloatArray()[arrayPos] = Float
	.parseFloat(content);
	} catch (NumberFormatException e) {
	throw createException(XCASParsingException.FLOAT_EXPECTED, content);
	}
	}
	break;
	}
	case STRING_TYPE: {
	((PrimitiveArrayFS) this.currentFS).toStringArray()[arrayPos] = content;
	break;
	}
	case FS_TYPE: {
	if (!emptyVal(content)) {
	((ReferenceArrayFS) this.currentFS).getIdRefArray()[arrayPos] = content;
	}
	break;
	}
	}
	++arrayPos;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#endDocument()
	*/
	public void endDocument() throws SAXException {
	// nothing to do
	}

	private XCASParsingException createException(int code) {
	XCASParsingException e = new XCASParsingException(code);
	String source = unknownXMLSource;
	String line = unknownXMLSource;
	String col = unknownXMLSource;
	if (locator != null) {
	source = locator.getSystemId();
	if (source == null) {
	source = locator.getPublicId();
	}
	if (source == null) {
	source = unknownXMLSource;
	}
	line = Integer.toString(locator.getLineNumber());
	col = Integer.toString(locator.getColumnNumber());
	}
	e.addArgument(source);
	e.addArgument(line);
	e.addArgument(col);
	return e;
	}

	private XCASParsingException createException(int code, String arg) {
	XCASParsingException e = createException(code);
	e.addArgument(arg);
	return e;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ErrorHandler#error(org.xml.sax.SAXParseException)
	*/
	public void error(SAXParseException e) throws SAXException {
	throw e;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ErrorHandler#fatalError(org.xml.sax.SAXParseException)
	*/
	public void fatalError(SAXParseException e) throws SAXException {
	throw e;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int)
	*/
	public void ignorableWhitespace(char[] arg0, int arg1, int arg2) throws SAXException {
	// Since we're not validating, we don't need to do anything; this won't
	// be called.
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ContentHandler#setDocumentLocator(org.xml.sax.Locator)
	*/
	public void setDocumentLocator(Locator loc) {
	// System.out.println("Setting document locator.");
	this.locator = loc;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.xml.sax.ErrorHandler#warning(org.xml.sax.SAXParseException)
	*/
	public void warning(SAXParseException e) throws SAXException {
	throw e;
	}

	private static final int INT_TYPE = 0;

	private static final int FLOAT_TYPE = 1;

	private static final int STRING_TYPE = 2;

	private static final int FS_TYPE = 3;

	private boolean isArrayType(String typeName) {
	return CAS.TYPE_NAME_INTEGER_ARRAY.equals(typeName)
	\|\| CAS.TYPE_NAME_FLOAT_ARRAY.equals(typeName)
	\|\| CAS.TYPE_NAME_STRING_ARRAY.equals(typeName)
	\|\| CAS.TYPE_NAME_FS_ARRAY.equals(typeName);
	}

	}