* 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.

*/

* XMI CAS deserializer. Used to read in a CAS from XML Metadata Interchange (XMI) format.

*/

    // ///////////////////////////////////////////////////////////////////////

    // 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, or document text element, or the end of the

    // XML input.

    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 a feature element. We expect the feature value.

    private static final int FEAT_CONTENT_STATE = 3;

   

    // Inside an element with the XMI namespace - indicating content that's

    // not part of the typesystem and should be ignored.

    private static final int IGNORING_XMI_ELEMENTS_STATE = 4;

    // Inside a reference feature element (e.g. <feat href="#1").

    // We expect no content, just the end of the element.

    private static final int REF_FEAT_STATE = 5;

    // End parser states.

    // ///////////////////////////////////////////////////////////////////////

    // For error message printing, if the Locator object can't provide source

    // of XML input.

    private static final String unknownXMLSource = "<unknown>";

    private String ID_ATTR_NAME = "xmi:id";

    // SAX locator. Used for error message generation.

    private Locator locator;

    // The CAS we're filling.

    private CASImpl casBeingFilled;

    // Store address of every FS we've deserialized, since we need to back

    // and apply fix-ups afterwards.

    private IntVector deserializedFsAddrs;

    // Store a separate vector of FSList nodes that were deserialized from multivalued properties.

    // These are special because their "head" feature needs remapping but their "tail" feature

    // doesn't.

    private IntVector fsListNodesFromMultivaluedProperties;

    // What we expect next.

    private int state;

    // StringBuffer to accumulate text.

    private StringBuffer buffer;

    // The address of the most recently created FS. Needed for embedded

    // feature values.

    private int currentAddr;

    // The type of the most recently created FS. Needed for arrays, also

    // useful for embedded feature values.

    private TypeImpl currentType;

    // the ID and values of arrays are stored on startElement, then used on

    // endElement to actually create the array. This is because in the case of

    // String arrays serialized with the values as child elements, we can't create

    // the array until we've seen all of the child elements.

    private int currentArrayId;

    private List<String> currentArrayElements;

    // Used for keeping track of multi-valued features read from subelements.

    // Keys are feature names, values are ArrayLists of strings,

    // where each String is one of the values to be assigned to the feature.

    private Map<String, List<String>> multiValuedFeatures = new TreeMap<String, List<String>>();

    // SofaFS type

    private int sofaTypeCode;

    // Sofa number feature code

    private int sofaNumFeatCode;

    // Annotation:sofa feature code

    private int sofaFeatCode;

    // Store IndexRepositories in a vector;

    private List<FSIndexRepository> indexRepositories;

    // and views too

    private List<CAS> views;

    // utilities for handling CAS list types

    private ListUtils listUtils;

    // type of each feature, according to constants below

    private int[] featureType;

    // true if unknown types should be ignored; false if they should cause an error

    boolean lenient;

    // number of oustanding startElement events that we are ignoring

    // we add 1 when an ignored element starts and subtract 1 when an ignored

    // element ends

    private int ignoreDepth = 0;

    // map from namespace prefixes to URIs. Allows namespace resolution even

    // with a non-namespace-enabled SAX parser.

    private Map<String, String> nsPrefixToUriMap = new HashMap<String, String>();

    // container for data shared between the XmiCasSerialier and

    // XmiDeserializer, to support things such as consistency of IDs across

    // multiple serializations.  This is also where the map from xmi:id to

    // FS address is stored.

    private XmiSerializationSharedData sharedData;

    // number of Sofas found so far

    private int nextSofaNum;

   

    //used for merging multiple XMI CASes into one CAS object.

    private int mergePoint;

   

    //Current out-of-typesystem element, if any

    private OotsElementData outOfTypeSystemElement = null;

    //local map from xmi:id to FS address, used when merging multiple XMI CASes

    //into one CAS object.

    private RedBlackTree<Integer> localXmiIdToFsAddrMap = new RedBlackTree<Integer>();

   

    //if mergepoint is set, are preexisting FS allowed, disallowed or ignored.

    AllowPreexistingFS allowPreexistingFS;

   

    //When deserializing delta CAS  preexisting FS, keep track of features that

    //have been deserialized. This is then compared to the all features for the

    //type and features that are not in the xmi are set to null.

    IntVector featsSeen = null;

   

    //set this flag if preexisting FS is encountered when deserializing

    //delta cas View referenceing disallowed preexisting FS member.

    //The preexisting members are ignored and deserialization allowed

    //to complete so that the CAS being filled is not corrupted.

    //An exception is thrown at the end.

    //NOTE: Since preexisting FSs are serialized first, when deserializing

    //of delta CAS with a disallowed preexisting FS, the error will be

    //caught and reported before any updates are made to the CAS being filled.

   

    boolean disallowedViewMemberEncountered;

   

    /**

     * Creates a SAX handler used for deserializing an XMI CAS.

     * @param aCAS CAS to deserialize into

     * @param lenient if true, unknown types/features result in an

     *   exception.  If false, unknown types/features are ignored.

     * @param sharedData data structure used to allow the XmiCasSerializer and

     *   XmiCasDeserializer to share information.

     * @param mergePoint used to support merging multiple XMI CASes.  If the

     *   mergePoint is negative, "normal" deserialization will be done,

     *   meaning the target CAS will be reset and the entire XMI content will

     *   be deserialized.  If the mergePoint is nonnegative (including 0), the

     *   target CAS will not be reset, and only Feature Structures whose

     *   xmi:id is strictly greater than the mergePoint value will be

     *   deserialized.

     */

    private XmiCasDeserializerHandler(CASImpl aCAS, boolean lenient,

            XmiSerializationSharedData sharedData, int mergePoint, AllowPreexistingFS allowPreexistingFS) {

      super();

      this.casBeingFilled = aCAS.getBaseCAS();

      this.lenient = lenient;

      this.sharedData =

        sharedData != null ? sharedData : new XmiSerializationSharedData();

      this.mergePoint = mergePoint;

      this.allowPreexistingFS = allowPreexistingFS;

      this.featsSeen = null;

      this.disallowedViewMemberEncountered = false;

      if (mergePoint < 0) {

        //If not merging, reset the CAS.

        //Necessary to get Sofas to work properly.

        casBeingFilled.resetNoQuestions();

       

        // clear ID mappings stored in the SharedData (from previous deserializations)

        this.sharedData.clearIdMap();

        //new Sofas start at 2

        this.nextSofaNum = 2;

      } else {

        this.nextSofaNum = ((CASImpl)this.casBeingFilled).getBaseSofaCount() + 1;

      }

      this.deserializedFsAddrs = new IntVector();

      this.fsListNodesFromMultivaluedProperties = new IntVector();

      this.buffer = new StringBuffer();

      this.indexRepositories = new ArrayList<FSIndexRepository>();

      this.views = new ArrayList<CAS>();

      indexRepositories.add(this.casBeingFilled.getBaseIndexRepository());

      // There should always be another index for the Initial View

      indexRepositories.add(this.casBeingFilled.getView(CAS.NAME_DEFAULT_SOFA).getIndexRepository());

      //add an entry to indexRepositories for each Sofa in the CAS (which can only happen if

      //a mergePoint was specified)

      FSIterator<SofaFS> sofaIter = this.casBeingFilled.getSofaIterator();

      while(sofaIter.hasNext()) {

        SofaFS sofa = (SofaFS)sofaIter.next();

        if (sofa.getSofaRef() == 1) {

          casBeingFilled.registerInitialSofa();

        } else {

          // add indexRepo for views other than the initial view

          indexRepositories.add(casBeingFilled.getSofaIndexRepository(sofa));

        }       

      }     

      final TypeSystemImpl tsOfReceivingCas = casBeingFilled.getTypeSystemImpl();

      this.sofaTypeCode = tsOfReceivingCas.ll_getCodeForTypeName(CAS.TYPE_NAME_SOFA);

      this.sofaNumFeatCode = tsOfReceivingCas.ll_getCodeForFeatureName(CAS.FEATURE_FULL_NAME_SOFANUM);

      this.sofaFeatCode = tsOfReceivingCas.ll_getCodeForFeatureName(CAS.FEATURE_FULL_NAME_SOFA);

      this.listUtils = new ListUtils(casBeingFilled, UIMAFramework.getLogger(XmiCasDeserializer.class), null);

      // populate feature type table

      this.featureType = new int[tsOfReceivingCas.getNumberOfFeatures() + 1];

      FeatureImpl feat;

      Iterator<Feature> it = tsOfReceivingCas.getFeatures();

      while (it.hasNext()) {

        feat = (FeatureImpl) it.next();

        featureType[feat.getCode()] = classifyType(tsOfReceivingCas.range(feat.getCode()));

      }

    }

    private final void resetBuffer() {

      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 {

      // org.apache.vinci.debug.Debug.p("startElement: " + qualifiedName);

      // if (attrs != null) {

      // for (int i=0; i<attrs.getLength(); i++) {

      // org.apache.vinci.debug.Debug.p("a: " + attrs.getQName(i) + " v: " + attrs.getValue(i));

      // }

      // }

      resetBuffer();

      switch (state) {

        case DOC_STATE: {

          // allow any root element name

          // extract xmlns:prefix=uri attributes into a map, which we can use to

          // resolve the prefixes even with a non-namespace-aware parser

          if (attrs != null) {

            for (int i = 0; i < attrs.getLength(); i++) {

              String attrName = attrs.getQName(i);

              if (attrName.startsWith("xmlns:")) {

                String prefix = attrName.substring(6);

                String uri = attrs.getValue(i);

                nsPrefixToUriMap.put(prefix, uri);

              }

            }

          }

          this.state = FS_STATE;

          break;

        }

        case FS_STATE: {

          // ignore elements with XMI prefix (such as XMI annotations)

          if (qualifiedName.startsWith("xmi")) {

            this.state = IGNORING_XMI_ELEMENTS_STATE;

            this.ignoreDepth++;

            return;

          }

         

          // if Delta CAS check if preexisting FS check if allowed

          if (this.mergePoint >= 0) {

            String id = attrs.getValue(ID_ATTR_NAME);

            if (id != null) {

              int idInt = Integer.parseInt(id);

              if (idInt > 0 && !this.isNewFS(idInt)) { //preexisting FS

              if (this.allowPreexistingFS == AllowPreexistingFS.ignore) { //skip elements whose ID is <= mergePoint

                this.state = IGNORING_XMI_ELEMENTS_STATE;

                this.ignoreDepth++;

                return;

              } else if (this.allowPreexistingFS == AllowPreexistingFS.disallow) { //fail

                CASRuntimeException e = new CASRuntimeException(

                        CASRuntimeException.DELTA_CAS_PREEXISTING_FS_DISALLOWED,

                        new String[] {ID_ATTR_NAME + "=" + id,

                                  nameSpaceURI,

                                  localName,

                                  qualifiedName});

                  throw e;

              }

              }

            }

          }

         

          if (nameSpaceURI == null || nameSpaceURI.length() == 0) {

            // parser may not be namespace-enabled, so try to resolve NS ourselves

            int colonIndex = qualifiedName.indexOf(':');

            if (colonIndex != -1) {

              String prefix = qualifiedName.substring(0, colonIndex);

              nameSpaceURI = (String) nsPrefixToUriMap.get(prefix);

              if (nameSpaceURI == null) {

                // unbound namespace. Rather than failing, just assume a reasonable default.

                nameSpaceURI = "http:///" + prefix + ".ecore";

              }

              localName = qualifiedName.substring(colonIndex + 1);

            } else // no prefix. Use default URI

            {

              nameSpaceURI = XmiCasSerializer.DEFAULT_NAMESPACE_URI;

            }

          }

          readFS(nameSpaceURI, localName, qualifiedName, attrs);

        

          multiValuedFeatures.clear();

          state = FEAT_STATE;

          break;

        }

        case FEAT_STATE: {

          //parsing a feature recorded as a child element

          //check for an "href" feature, used for references

          String href = attrs.getValue("href");

          if (href != null && href.startsWith("#")) {          

            //for out-of-typesystem objects, there's special handling here

            //to keep track of the fact this was an href so we re-serialize

            //correctly.

            if (this.outOfTypeSystemElement != null) {

              XmlElementName elemName = new XmlElementName(nameSpaceURI, localName, qualifiedName);

              List<XmlAttribute> ootsAttrs = new ArrayList<XmlAttribute>();

              ootsAttrs.add(new XmlAttribute("href", href));

              XmlElementNameAndContents elemWithContents = new XmlElementNameAndContents(elemName, null, ootsAttrs);

              this.outOfTypeSystemElement.childElements.add(elemWithContents);

            }

            else {

              //In-typesystem FS, so we can forget this was an href and just add

              //the integer value, which will be interpreted as a reference later.

              //NOTE: this will end up causing it to be reserialized as an attribute

              //rather than an element, but that is not in violation of the XMI spec.

              List<String> valueList = this.multiValuedFeatures.get(qualifiedName);

              if (valueList == null) {

                valueList = new ArrayList<String>();

                this.multiValuedFeatures.put(qualifiedName, valueList);

              }

              valueList.add(href.substring(1));

            }                        

            state = REF_FEAT_STATE;

          }

          else {

            //non-reference feature, expecting feature value as character content

            state = FEAT_CONTENT_STATE;

          }

          break;

        }

        case IGNORING_XMI_ELEMENTS_STATE: {

          ignoreDepth++;

          break;

        }

        default: {

          // If we're not in an element expecting state, raise an error.

          throw createException(XCASParsingException.TEXT_EXPECTED, qualifiedName);

        }

      }

    }

    // Create a new FS.

    private void readFS(String nameSpaceURI, String localName, String qualifiedName,

            Attributes attrs) throws SAXException {

      String typeName = xmiElementName2uimaTypeName(nameSpaceURI, localName);

     

      currentType = (TypeImpl) ts.getType(typeName);

      if (currentType == null) {

        // ignore NULL type

        if ("uima.cas.NULL".equals(typeName)) {

          return;

        }

        // special processing for uima.cas.View (encodes indexed FSs)

        if ("uima.cas.View".equals(typeName)) {

          processView(attrs.getValue("sofa"), attrs.getValue("members"));

          String added = attrs.getValue("added_members");

          String deleted = attrs.getValue("deleted_members");

          String reindexed = attrs.getValue("reindexed_members");

          processView(attrs.getValue("sofa"), added,deleted,reindexed);

          return;

        }

        // type is not in our type system

        if (!lenient) {

          throw createException(XCASParsingException.UNKNOWN_TYPE, typeName);

        } else {

          addToOutOfTypeSystemData(

              new XmlElementName(nameSpaceURI, localName, qualifiedName), attrs);                 

        }

        return;

      } else if (casBeingFilled.isArrayType(currentType)) {

        // store ID and array values (if specified as attribute).

        // we will actually create the array later, in endElement.

        String idStr = attrs.getValue(ID_ATTR_NAME);

        currentArrayId = idStr == null ? -1 : Integer.parseInt(idStr);

        String elements = attrs.getValue("elements");

        // special parsing for byte arrays (they are serialized as a hex

        // string. And we create them here instead of parsing to a string

        // array, for efficiency.

        if (casBeingFilled.isByteArrayType(currentType)) {

          createByteArray(elements, currentArrayId, 0);

        } else {

          if (elements != null) {

            String[] parsedElements = parseArray(elements);

            currentArrayElements = Arrays.asList(parsedElements);

          } else {

            currentArrayElements = null;

          }

        }

      } else {

      String idStr = attrs.getValue(ID_ATTR_NAME);

      int xmiId = idStr == null ? -1 : Integer.parseInt(idStr);

      if (isNewFS(xmiId)) {  //new FS so create it. 

        final int addr = casBeingFilled.ll_createFS(currentType.getCode());

          readFS(addr, attrs);

      } else {  //preexisting

        if (this.allowPreexistingFS == AllowPreexistingFS.disallow) {

          CASRuntimeException e = new CASRuntimeException(

                      CASRuntimeException.DELTA_CAS_PREEXISTING_FS_DISALLOWED,

                      new String[] {ID_ATTR_NAME + "=" + idStr,

                                nameSpaceURI,

                                localName,

                                qualifiedName});

          throw e;

        } else if (this.allowPreexistingFS == AllowPreexistingFS.allow) { //get the FS

          final int addr = getFsAddrForXmiId(xmiId);

               readFS(addr,attrs);

        } // otherwise ignore

      }

      }

    }

    /**

     * Handles the processing of a cas:View element in the XMI. The cas:View element encodes indexed

     * FSs.

     *

     * @param sofa

     *          xmi:id of the sofa for this view, null indicates base CAS "view"

     * @param membersString

     *          whitespace-separated string of FS addresses. Each FS is to be added to the specified

     *          sofa's index repository

     */

    private void processView(String sofa, String membersString) throws SAXParseException {

      // TODO: this requires View to come AFTER all of its members

      if (membersString != null) {

        // a view with no Sofa will be added to the 1st, _InitialView, index

        int sofaNum = 1;

        boolean newview = false;

        if (sofa != null) {

          // translate sofa's xmi:id into its sofanum

          int sofaXmiId = Integer.parseInt(sofa);

          newview = isNewFS(sofaXmiId);

          int sofaAddr;

          try {

            sofaAddr = getFsAddrForXmiId(sofaXmiId);

          } catch (NoSuchElementException e) {

            throw createException(XCASParsingException.UNKNOWN_ID, Integer.toString(sofaXmiId));

          }

          sofaNum = casBeingFilled.getFeatureValue(sofaAddr, sofaNumFeatCode);

        }

        FSIndexRepositoryImpl indexRep = (FSIndexRepositoryImpl) indexRepositories.get(sofaNum);

        // TODO: optimize by going straight to int[] without going through

        // intermediate String[]?

        String[] members = parseArray(membersString);

        for (int i = 0; i < members.length; i++) {

          int id = Integer.parseInt(members[i]);

          // special handling for merge operations ...

          if (!newview && !isNewFS(id)) {

            // a pre-existing FS is indexed in a pre-existing view

            if (this.allowPreexistingFS == AllowPreexistingFS.ignore) {

              // merging with full CAS: ignore anything below the high water mark

              continue;

            }

            if (this.allowPreexistingFS == AllowPreexistingFS.disallow) {

              // merging with delta CAS: flag it

              this.disallowedViewMemberEncountered = true;

              continue;

            }

          }

          // have to map each ID to its "real" address (TODO: optimize?)

          //TODO: currently broken, can't use XmiSerializationSharedData for

          //this id mapping when merging, need local map

          try {

            int addr = getFsAddrForXmiId(id);

            indexRep.addFS(addr);

          } catch (NoSuchElementException e) {

            if (!lenient) {

              throw createException(XCASParsingException.UNKNOWN_ID, Integer.toString(id));

            }

            else {

              //unknown view member may be an OutOfTypeSystem FS

              this.sharedData.addOutOfTypeSystemViewMember(sofa, members[i]);

            }

          }

        }

      }

    }

   

   

    /**

     * Handles the processing of a cas:View element in the XMI. The cas:View element encodes indexed

     * FSs.

     *

     * @param sofa

     *          xmi:id of the sofa for this view, null indicates base CAS "view"

     * @param membersString

     *          whitespace-separated string of FS addresses. Each FS is to be added to the specified

     *          sofa's index repository

     */

    private void processView(String sofa, String addmembersString,

        String delmemberString, String reindexmemberString) throws SAXParseException {

      // TODO: this requires View to come AFTER all of its members

      if (addmembersString != null) {

        processView(sofa, addmembersString);

      }

      int sofaNum = 1;

      FSIndexRepositoryImpl indexRep = null;

      if (delmemberString != null || reindexmemberString != null) {

      if (sofa != null) {

              // translate sofa's xmi:id into its sofanum

              int sofaXmiId = Integer.parseInt(sofa);

              int sofaAddr = getFsAddrForXmiId(sofaXmiId);

              sofaNum = casBeingFilled.getFeatureValue(sofaAddr, sofaNumFeatCode);

        }

        indexRep = (FSIndexRepositoryImpl) indexRepositories.get(sofaNum);

        // TODO: optimize by going straight to int[] without going through

        // intermediate String[]?

        if (delmemberString != null) {

          String[] members = parseArray(delmemberString);

          for (int i = 0; i < members.length; i++) {

            int id = Integer.parseInt(members[i]);

            if (!isNewFS(id)) {  //preexisting FS

              if (this.allowPreexistingFS == AllowPreexistingFS.disallow) {

                this.disallowedViewMemberEncountered = true;  //ignore but flag it.

                continue;

              } else if (this.allowPreexistingFS == AllowPreexistingFS.ignore) {

                continue;  //ignore

              }

            }

          // have to map each ID to its "real" address (TODO: optimize?)

          //TODO: currently broken, can't use XmiSerializationSharedData for

          //this id mapping when merging, need local map

          try {

            int addr = getFsAddrForXmiId(id);

            indexRep.removeFS(addr);

          } catch (NoSuchElementException e) {

            if (!lenient) {

                throw createException(XCASParsingException.UNKNOWN_ID, Integer.toString(id));

              } else {

            //unknown view member may be an OutOfTypeSystem FS

            this.sharedData.addOutOfTypeSystemViewMember(sofa, members[i]);

            }

          }

          } 

        }

        if (reindexmemberString != null) {

          String[] members = parseArray(reindexmemberString);

          for (int i = 0; i < members.length; i++) {

            int id = Integer.parseInt(members[i]);

            if (!isNewFS(id)) { //preexising FS

                if (this.allowPreexistingFS == AllowPreexistingFS.disallow) {

                  this.disallowedViewMemberEncountered = true; //ignore but flag it.

                  continue;

                } else if (this.allowPreexistingFS == AllowPreexistingFS.ignore) {

                  continue; 

                }

            }

            // have to map each ID to its "real" address (TODO: optimize?)

            //TODO: currently broken, can't use XmiSerializationSharedData for

            //this id mapping when merging, need local map

            try {

              int addr = getFsAddrForXmiId(id);

              indexRep.removeFS(addr);

              indexRep.addFS(addr);

            } catch (NoSuchElementException e) {

              if (!lenient) {

                throw createException(XCASParsingException.UNKNOWN_ID, Integer.toString(id));

              } else {

              //unknown view member may be an OutOfTypeSystem FS

              this.sharedData.addOutOfTypeSystemViewMember(sofa, members[i]);

              }

            }

          } 

        }

      }

    }

    /**

     *

     * @param addr

     * @param attrs

     * @throws SAXException

     */

    private void readFS(final int addr, Attributes attrs) throws SAXException {

      // Hang on to address for handle features encoded as child elements

      this.currentAddr = addr;

      int id = -1;

      String attrName, attrValue;

      final int typeCode = casBeingFilled.getHeapValue(addr);

      final Type type = casBeingFilled.getTypeSystemImpl().ll_getTypeForCode(typeCode);

      int thisSofaNum = 0;

     

      //is it a new FS

      try {

        id = Integer.parseInt(attrs.getValue(ID_ATTR_NAME));

      } catch (NumberFormatException e) {

        throw createException(XCASParsingException.ILLEGAL_ID, attrs.getValue(ID_ATTR_NAME));

      }

      boolean newFS = this.isNewFS(id);

     

      if (sofaTypeCode == typeCode) {

        String sofaID = attrs.getValue(CAS.FEATURE_BASE_NAME_SOFAID);

        if (sofaID.equals(CAS.NAME_DEFAULT_SOFA) || sofaID.equals("_DefaultTextSofaName")) {

          // initial view Sofa always has sofaNum = 1

          thisSofaNum = 1;

        } else {

          if (newFS) { 

            thisSofaNum = this.nextSofaNum++;

          } else {

          thisSofaNum = Integer.parseInt(attrs.getValue(CAS.FEATURE_BASE_NAME_SOFANUM));

          }

        }

      }

     

      this.featsSeen = null;

      for (int i = 0; i < attrs.getLength(); i++) {

        attrName = attrs.getQName(i);

        attrValue = attrs.getValue(i);

        if (attrName.equals(ID_ATTR_NAME)) {

          try {

            id = Integer.parseInt(attrValue);

            newFS = this.isNewFS(id);

            if (sofaTypeCode != typeCode && !newFS) {

              this.featsSeen = new IntVector(attrs.getLength());

            } else {

              this.featsSeen = null;

            }

          } catch (NumberFormatException e) {

            throw createException(XCASParsingException.ILLEGAL_ID, attrValue);

          }

        } else {

          if (sofaTypeCode == typeCode && attrName.equals(CAS.FEATURE_BASE_NAME_SOFAID)) {

            if (attrValue.equals("_DefaultTextSofaName")) {

              // First change old default Sofa name into the new one

              attrValue = CAS.NAME_DEFAULT_SOFA;

            }

          } else if (sofaTypeCode == typeCode && attrName.equals(CAS.FEATURE_BASE_NAME_SOFANUM)) {

            attrValue = Integer.toString(thisSofaNum);

          }

          int featCode = handleFeature(type, addr, attrName, attrValue, newFS);

          //if processing delta cas preexisting FS, keep track of features that have

          //been deserialized.

          if (this.featsSeen != null && !newFS && featCode != -1) {

            this.featsSeen.add(featCode);

          }

        }

      }

     

      if (sofaTypeCode == typeCode && newFS) {

        // If a Sofa, create CAS view to get new indexRepository

        SofaFS sofa = (SofaFS) casBeingFilled.createFS(addr);

        // also add to indexes so we can retrieve the Sofa later

        casBeingFilled.getBaseIndexRepository().addFS(sofa);

        CAS view = casBeingFilled.getView(sofa);

        if (sofa.getSofaRef() == 1) {

          casBeingFilled.registerInitialSofa();

        } else {

          // add indexRepo for views other than the initial view

          indexRepositories.add(casBeingFilled.getSofaIndexRepository(sofa));

        }

        ((CASImpl) view).registerView(sofa);

        views.add(view);

      }

      deserializedFsAddrs.add(addr);

      addFsAddrXmiIdMapping(addr, id);

    }

    // 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));

    }

    private int handleFeature(final Type type, int addr, String featName, String featVal, boolean newFS) throws SAXException {

      final FeatureImpl feat = (FeatureImpl) type.getFeatureByBaseName(featName);

      if (feat == null) {

        if (!this.lenient) {

          throw createException(XCASParsingException.UNKNOWN_FEATURE, featName);

        }

        else {

          sharedData.addOutOfTypeSystemAttribute(addr, featName, featVal);

        }

        return -1;

      }

     

      //Sofa FS 

      //only update Sofa data features and mime type feature. skip other features.

      //skip Sofa data features if Sofa data is already set.

      //these features may not be modified.

      if (sofaTypeCode == casBeingFilled.getHeapValue(addr) && !isNewFS(addr) ) {

      if (featName.equals(CAS.FEATURE_BASE_NAME_SOFAID) ||

          featName.equals(CAS.FEATURE_BASE_NAME_SOFANUM))   {

          return feat.getCode();

      } else if (featName.equals(CAS.FEATURE_BASE_NAME_SOFASTRING)  ||

               featName.equals(CAS.FEATURE_BASE_NAME_SOFAURI) ||

               featName.equals(CAS.FEATURE_BASE_NAME_SOFAARRAY)) {

          int currVal = casBeingFilled.getFeatureValue(addr, feat.getCode());

        if (currVal != 0)

          return feat.getCode();

      }

      }   

      handleFeature(addr, feat.getCode(), featVal);

      return feat.getCode();

    }

    private int handleFeature(final Type type, int addr, String featName, List<String> featVals) throws SAXException {

      final FeatureImpl feat = (FeatureImpl) type.getFeatureByBaseName(featName);

      if (feat == null) {

        if (!this.lenient) {

          throw createException(XCASParsingException.UNKNOWN_FEATURE, featName);

        }

        else {

          sharedData.addOutOfTypeSystemChildElements(addr, featName, featVals);

        }

        return -1;

      }

      handleFeature(addr, feat.getCode(), featVals);

      return feat.getCode();

    }

    /**

     * Set a CAS feature from an XMI attribute.

     *

     * @param addr

     *          address of FS containing the feature

     * @param featCode

     *          code of feature to set

     * @param featVal

     *          string representation of the feature value

     * @throws SAXException

     */

    private void handleFeature(int addr, int featCode, String featVal) throws SAXException {

      switch (featureType[featCode]) {

        case LowLevelCAS.TYPE_CLASS_INT: {

          try {

            if (!emptyVal(featVal)) {

              if (featCode == sofaFeatCode) {

                // special handling for "sofa" feature of annotation. Need to change

                // it from a sofa reference into a sofa number

                int sofaXmiId = Integer.parseInt(featVal);

                int sofaAddr = getFsAddrForXmiId(sofaXmiId);

                int sofaNum = casBeingFilled.getFeatureValue(sofaAddr, sofaNumFeatCode);

                casBeingFilled.setFeatureValue(addr, featCode, sofaNum);

              } else {

                casBeingFilled.setFeatureValue(addr, featCode, Integer.parseInt(featVal));

              }

            }

          } catch (NumberFormatException e) {

            throw createException(XCASParsingException.INTEGER_EXPECTED, featVal);

          }

          break;

        }

        case LowLevelCAS.TYPE_CLASS_FLOAT:

        case LowLevelCAS.TYPE_CLASS_BOOLEAN:

        case LowLevelCAS.TYPE_CLASS_BYTE:

        case LowLevelCAS.TYPE_CLASS_SHORT:

        case LowLevelCAS.TYPE_CLASS_LONG:

        case LowLevelCAS.TYPE_CLASS_DOUBLE: {

          try {

            if (!emptyVal(featVal)) {

              casBeingFilled.setFeatureValueFromString(addr, featCode, featVal);

              // cas.setFloatValue(addr, featCode, Float.parseFloat(featVal));

            }

          } catch (NumberFormatException e) {

            throw createException(XCASParsingException.FLOAT_EXPECTED, featVal);

          }

          break;

        }

        case LowLevelCAS.TYPE_CLASS_STRING: {

          if (featVal != null) // do not use empty value since that would filter out ""

          {

          //if (newFS) {

            //  casBeingFilled.setStringValue(addr, featCode, featVal);

          //} else {

            //preexisting FS, compare with original value in CAS and set only if different.

            String origValue = casBeingFilled.getStringValue(addr, featCode);

            if (origValue == null || !featVal.equals(origValue)) {

              casBeingFilled.setStringValue(addr, featCode, featVal);

            }

          //}

          }

          break;

        }

        case LowLevelCAS.TYPE_CLASS_FS: {

          try {

            if (!emptyVal(featVal)) { this.

              casBeingFilled.setFeatureValue(addr, featCode, Integer.parseInt(featVal));

            }

          } catch (NumberFormatException e) {

            throw createException(XCASParsingException.INTEGER_EXPECTED, featVal);

          }

          break;

        }

          // For array types and list features, there are two kinds of serializations.

          // If the feature has multipleReferencesAllowed = true, then it should have been

          // serialized as a normal FS. If it has multipleReferencesAllowed = false, then

          // it should have been serialized as a multi-valued property.

        case LowLevelCAS.TYPE_CLASS_INTARRAY:

        case LowLevelCAS.TYPE_CLASS_FLOATARRAY:

        case LowLevelCAS.TYPE_CLASS_STRINGARRAY:

        case LowLevelCAS.TYPE_CLASS_BOOLEANARRAY:

        case LowLevelCAS.TYPE_CLASS_BYTEARRAY:

        case LowLevelCAS.TYPE_CLASS_SHORTARRAY:

        case LowLevelCAS.TYPE_CLASS_LONGARRAY:

        case LowLevelCAS.TYPE_CLASS_DOUBLEARRAY:

        case LowLevelCAS.TYPE_CLASS_FSARRAY: {

          if (ts.ll_getFeatureForCode(featCode).isMultipleReferencesAllowed()) {

            // do the usual FS deserialization

            try {

              if (!emptyVal(featVal)) {

                casBeingFilled.setFeatureValue(addr, featCode, Integer.parseInt(featVal));

              }

            } catch (NumberFormatException e) {

              throw createException(XCASParsingException.INTEGER_EXPECTED, featVal);

            }

          } else {

            // Do the multivalued property deserialization.

            // However, byte arrays have a special serialization (as hex digits)

            if (featureType[featCode] == LowLevelCAS.TYPE_CLASS_BYTEARRAY) {

              int currFeatVal = casBeingFilled.getFeatureValue(addr, featCode);

              int casArray = 0;

              casArray = createByteArray(featVal,-1,currFeatVal);

              if (casArray != currFeatVal) {

                casBeingFilled.setFeatureValue(addr, featCode, casArray);      

              }

            

            } else {

              String[] arrayVals = parseArray(featVal);

              handleFeature(addr, featCode, Arrays.asList(arrayVals));

            }

          }

          break;

        }

          // For list types, we do the same as for array types UNLESS we're dealing with

          // the tail feature of another list node. In that case we do the usual FS deserialization.

        case XmiCasSerializer.TYPE_CLASS_INTLIST:

        case XmiCasSerializer.TYPE_CLASS_FLOATLIST:

        case XmiCasSerializer.TYPE_CLASS_STRINGLIST:

        case XmiCasSerializer.TYPE_CLASS_FSLIST: {

          if (ts.ll_getFeatureForCode(featCode).isMultipleReferencesAllowed()) {

            // do the usual FS deserialization

            try {

              if (!emptyVal(featVal)) {

                casBeingFilled.setFeatureValue(addr, featCode, Integer.parseInt(featVal));

              }

            } catch (NumberFormatException e) {

              throw createException(XCASParsingException.INTEGER_EXPECTED, featVal);

            }

          } else // do the multivalued property deserialization, like arrays

          {

            String[] arrayVals = parseArray(featVal);

            handleFeature(addr, featCode, Arrays.asList(arrayVals));

          }

          break;

        }

        default: {

          assert false; // this should be an exhaustive case block

        }

      }

    }

    /**

     * Parse an XMI multi-valued attribute into a String array, by splitting on whitespace.

     *

     * @param val

     *          XMI attribute value

     * @return an array with each array value as an element

     */

    private String[] parseArray(String val) {

      String[] arrayVals;

      val = val.trim();

      if (emptyVal(val)) {

        arrayVals = new String[0];

      } else {

        arrayVals = val.split("\\s+");

      }

      return arrayVals;

    }

    /**

     * Set a CAS feature from an array of Strings. This supports the XMI syntax where each value is

     * listed as a separate subelement.

     *

     * @param addr

     *          address of FS containing the feature

     * @param featCode

     *          code of feature to set

     * @param featVals

     *          List of Strings, each String representing one value for the feature

     * @throws SAXException

     */

    private void handleFeature(int addr, int featCode, List<String> featVals) throws SAXException {

      switch (featureType[featCode]) {

        case LowLevelCAS.TYPE_CLASS_INT:

        case LowLevelCAS.TYPE_CLASS_FLOAT:

        case LowLevelCAS.TYPE_CLASS_STRING:

        case LowLevelCAS.TYPE_CLASS_BOOLEAN:

        case LowLevelCAS.TYPE_CLASS_BYTE:

        case LowLevelCAS.TYPE_CLASS_SHORT:

        case LowLevelCAS.TYPE_CLASS_LONG:

        case LowLevelCAS.TYPE_CLASS_DOUBLE:

        case LowLevelCAS.TYPE_CLASS_FS:

          if (featVals.size() != 1) {

            throw new SAXParseException(I18nUtil.localizeMessage(

                    UIMAException.STANDARD_MESSAGE_CATALOG, Locale.getDefault(),

                    "multiple_values_unexpected",

                    new Object[] { ts.ll_getFeatureForCode(featCode).getName() }), locator);

          } else {

            handleFeature(addr, featCode, featVals.get(0));

          }

          break;

        case LowLevelCAS.TYPE_CLASS_INTARRAY:

        case LowLevelCAS.TYPE_CLASS_FLOATARRAY:

        case LowLevelCAS.TYPE_CLASS_STRINGARRAY:

        case LowLevelCAS.TYPE_CLASS_BOOLEANARRAY:

        case LowLevelCAS.TYPE_CLASS_BYTEARRAY:

        case LowLevelCAS.TYPE_CLASS_SHORTARRAY:

        case LowLevelCAS.TYPE_CLASS_LONGARRAY:

        case LowLevelCAS.TYPE_CLASS_DOUBLEARRAY:

        case LowLevelCAS.TYPE_CLASS_FSARRAY: {

          int casArray = 0;

          int currVal = casBeingFilled.getFeatureValue(addr, featCode);

          casArray = createArray(casBeingFilled.getTypeSystemImpl().range(featCode), featVals, -1, currVal);

          if (currVal != casArray) {

            casBeingFilled.setFeatureValue(addr, featCode, casArray);

          }

          //add to nonshared fs to encompassing FS map

          if (!ts.ll_getFeatureForCode(featCode).isMultipleReferencesAllowed()) {

            addNonsharedFSToEncompassingFSMapping(casArray, addr);

          }

          break;

        }

        /**

        case LowLevelCAS.TYPE_CLASS_FSARRAY: {

          int casArray = createArray(casBeingFilled.getTypeSystemImpl().range(featCode), featVals, -1);

          casBeingFilled.setFeatureValue(addr, featCode, casArray);

          break;

        }

        **/

        case XmiCasSerializer.TYPE_CLASS_INTLIST: {

          int listFS = casBeingFilled.getFeatureValue(addr, featCode);

          if (listFS == 0) {

            listFS = listUtils.createIntList(featVals);

            casBeingFilled.setFeatureValue(addr, featCode, listFS);

          } else {

          listUtils.updateIntList(listFS, featVals);

          }

          //add to nonshared fs to encompassing FS map

          if (!ts.ll_getFeatureForCode(featCode).isMultipleReferencesAllowed()) {

            addNonsharedFSToEncompassingFSMapping(listFS, addr);

          }

          break;