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

*/

* Utilities for creating and setting up CASes. Also includes utilities for merging CAS type

* systems.

*

*

*/

  /**

   * Creates a new CAS instance. Note this method does not work for Aggregate Analysis Engine

   * descriptors -- use {@link #createCas(AnalysisEngineDescription)} instead.

   *

   * @param aMetaData

   *          metadata for the analysis engine that will process this CAS. This is used to set up

   *          the CAS's type system and indexes.

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(AnalysisEngineMetaData aMetaData)

          throws ResourceInitializationException {

    List list = new ArrayList();

    list.add(aMetaData);

    return createCas(list);

  }

  /**

   * Creates a new CAS instance.

   *

   * @param aMetaData

   *          metadata for the resource that will process this CAS. This is used to set up the CAS's

   *          type system and indexes.

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(ProcessingResourceMetaData aMetaData)

          throws ResourceInitializationException {

    List list = new ArrayList();

    list.add(aMetaData);

    return createCas(list);

  }

  /**

   * Creates a new CAS instance for an Analysis Engine. This works for both primitive and aggregate

   * analysis engines.

   *

   * @param aDescription

   *          description of the anlaysis engine that will process this CAS. This is used to set up

   *          the CAS's type system and indexes.

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(AnalysisEngineDescription aDescription)

          throws ResourceInitializationException {

    return createCas(aDescription, UIMAFramework.getDefaultPerformanceTuningProperties());

  }

  /**

   * Creates a new CAS instance for an Analysis Engine. This works for both primitive and aggregate

   * analysis engines.

   *

   * @param aDescription

   *          description of the anlaysis engine that will process this CAS. This is used to set up

   *          the CAS's type system and indexes.

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(AnalysisEngineDescription aDescription,

          Properties aPerformanceTuningSettings) throws ResourceInitializationException {

    List list = new ArrayList();

    list.add(aDescription);

    return createCas(list, aPerformanceTuningSettings);

  }

  /**

   * Creates a new CAS instance for a collection of CAS Processors. This method correctly handles

   * aggregate as well as primitive analysis engines

   * <p>

   * If you pass this method objects of type {@link AnalysisEngineDescription},

   * {@link CollectionReaderDescription}, {@link CasInitializerDescription}, or

   * {@link CasConsumerDescription}, it will not instantiate the components. It will just extract

   * the type system information from the descriptor. For any other kind of

   * {@link ResourceSpecifier}, it will call

   * {@link UIMAFramework#produceResource(org.apache.uima.resource.ResourceSpecifier, Map)}. For

   * example, if a {@link URISpecifier} is passed, a remote connection will be established and the

   * service will be queries for its metadata. An exception will be thrown if the connection can not

   * be opened.

   *

   * @param aComponentDescriptionsOrMetaData

   *          a collection of {@link ResourceSpecifier}, {@link ProcessingResourceMetaData},

   *          {@link TypeSystemDescription}, {@link FsIndexCollection}, or {@link TypePriorities}

   *          objects.

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(Collection aComponentDescriptionsOrMetaData)

          throws ResourceInitializationException {

    return createCas(aComponentDescriptionsOrMetaData, UIMAFramework

            .getDefaultPerformanceTuningProperties());

  }

  /**

   * Creates a new CAS instance for a collection of CAS Processors. This method correctly handles

   * aggregate as well as primitive analysis engines

   * <p>

   * If you pass this method objects of type {@link AnalysisEngineDescription},

   * {@link CollectionReaderDescription}, {@link CasInitializerDescription}, or

   * {@link CasConsumerDescription}, it will not instantiate the components. It will just extract

   * the type system information from the descriptor. For any other kind of

   * {@link ResourceSpecifier}, it will call

   * {@link UIMAFramework#produceResource(org.apache.uima.resource.ResourceSpecifier, Map)}. For

   * example, if a {@link URISpecifier} is passed, a remote connection will be established and the

   * service will be queries for its metadata. An exception will be thrown if the connection can not

   * be opened.

   *

   * @param aComponentDescriptionsOrMetaData

   *          a collection of {@link ResourceSpecifier}, {@link ProcessingResourceMetaData},

   *          {@link TypeSystemDescription}, {@link FsIndexCollection}, or {@link TypePriorities}

   *          objects.

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(Collection aComponentDescriptionsOrMetaData,

          Properties aPerformanceTuningSettings) throws ResourceInitializationException {

    return createCas(aComponentDescriptionsOrMetaData, aPerformanceTuningSettings, UIMAFramework

            .newDefaultResourceManager());

  }

  /**

   * Creates a new CAS instance for a collection of CAS Processors. This method correctly handles

   * aggregate as well as primitive analysis engines

   * <p>

   * If you pass this method objects of type {@link AnalysisEngineDescription},

   * {@link CollectionReaderDescription}, {@link CasInitializerDescription}, or

   * {@link CasConsumerDescription}, it will not instantiate the components. It will just extract

   * the type system information from the descriptor. For any other kind of

   * {@link ResourceSpecifier}, it will call

   * {@link UIMAFramework#produceResource(org.apache.uima.resource.ResourceSpecifier, Map)}. For

   * example, if a {@link URISpecifier} is passed, a remote connection will be established and the

   * service will be queries for its metadata. An exception will be thrown if the connection can not

   * be opened.

   *

   * @param aComponentDescriptionsOrMetaData

   *          a collection of {@link ResourceSpecifier}, {@link ProcessingResourceMetaData},

   *          {@link TypeSystemDescription}, {@link FsIndexCollection}, or {@link TypePriorities}

   *          objects.

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   * @param aResourceManager

   *          the resource manager to use to resolve import declarations within the metadata

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(Collection aComponentDescriptionsOrMetaData,

          Properties aPerformanceTuningSettings, ResourceManager aResourceManager)

          throws ResourceInitializationException {

    // build a list of metadata objects

    List mdList = getMetaDataList(aComponentDescriptionsOrMetaData, aResourceManager);

    // extract TypeSystems, TypePriorities, and FsIndexes from metadata

    List typeSystems = new ArrayList();

    List typePriorities = new ArrayList();

    List fsIndexes = new ArrayList();

    Iterator it = mdList.iterator();

    while (it.hasNext()) {

      ProcessingResourceMetaData md = (ProcessingResourceMetaData) it.next();

      if (md.getTypeSystem() != null)

        typeSystems.add(md.getTypeSystem());

      if (md.getTypePriorities() != null)

        typePriorities.add(md.getTypePriorities());

      if (md.getFsIndexCollection() != null)

        fsIndexes.add(md.getFsIndexCollection());

    }

    // merge

    TypeSystemDescription aggTypeDesc = mergeTypeSystems(typeSystems, aResourceManager);

    TypePriorities aggTypePriorities = mergeTypePriorities(typePriorities, aResourceManager);

    FsIndexCollection aggIndexColl = mergeFsIndexes(fsIndexes, aResourceManager);

    return createCas(aggTypeDesc, aggTypePriorities, aggIndexColl.getFsIndexes(),

            aPerformanceTuningSettings, aResourceManager);

  }

  /**

   * Creates a new CAS instance.

   *

   * @param aTypeSystem

   *          type system to install in the CAS

   * @param aTypePriorities

   *          type priorities to install in the CAS

   * @param aFsIndexes

   *          indexes to install in the CAS

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(TypeSystemDescription aTypeSystem, TypePriorities aTypePriorities,

          FsIndexDescription[] aFsIndexes) throws ResourceInitializationException {

    return createCas(aTypeSystem, aTypePriorities, aFsIndexes, null, null);

  }

  /**

   * Creates a new CAS instance.

   *

   * @param aTypeSystem

   *          type system to install in the CAS

   * @param aTypePriorities

   *          type priorities to install in the CAS

   * @param aFsIndexes

   *          indexes to install in the CAS

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(TypeSystemDescription aTypeSystem, TypePriorities aTypePriorities,

          FsIndexDescription[] aFsIndexes, Properties aPerformanceTuningSettings)

          throws ResourceInitializationException {

    return createCas(aTypeSystem, aTypePriorities, aFsIndexes, aPerformanceTuningSettings, null);

  }

  /**

   * Creates a new CAS instance.

   *

   * @param aTypeSystem

   *          type system to install in the CAS

   * @param aTypePriorities

   *          type priorities to install in the CAS

   * @param aFsIndexes

   *          indexes to install in the CAS

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(TypeSystemDescription aTypeSystem, TypePriorities aTypePriorities,

          FsIndexDescription[] aFsIndexes, Properties aPerformanceTuningSettings,

          ResourceManager aResourceManager) throws ResourceInitializationException {

    return doCreateCas(null, aTypeSystem, aTypePriorities, aFsIndexes, aPerformanceTuningSettings,

            aResourceManager);

  }

  /**

   * Creates a new CAS instance for a collection of CAS Processors, which. reuses an existing type

   * system. Using this method allows several CASes to all share the exact same type system object.

   * This method correctly handles aggregate as well as primitive analysis engines.

   * <p>

   * If you pass this method objects of type {@link AnalysisEngineDescription},

   * {@link CollectionReaderDescription}, {@link CasInitializerDescription}, or

   * {@link CasConsumerDescription}, it will not instantiate the components. It will just extract

   * the type system information from the descriptor. For any other kind of

   * {@link ResourceSpecifier}, it will call

   * {@link UIMAFramework#produceResource(org.apache.uima.resource.ResourceSpecifier, Map)}. For

   * example, if a {@link URISpecifier} is passed, a remote connection will be established and the

   * service will be queries for its metadata. An exception will be thrown if the connection can not

   * be opened.

   *

   * @param aComponentDescriptionsOrMetaData

   *          a collection of {@link ResourceSpecifier}, {@link ProcessingResourceMetaData},

   *          {@link TypeSystemDescription}, {@link FsIndexCollection}, or {@link TypePriorities}

   *          objects.

   * @param aTypeSystem

   *          type system to install in the CAS, null if none

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(Collection aComponentDescriptionsOrMetaData, TypeSystem aTypeSystem,

          Properties aPerformanceTuningSettings) throws ResourceInitializationException {

    return createCas(aComponentDescriptionsOrMetaData, aTypeSystem, aPerformanceTuningSettings,

            UIMAFramework.newDefaultResourceManager());

  }

  /**

   * Creates a new CAS instance for a collection of CAS Processors, which. reuses an existing type

   * system. Using this method allows several CASes to all share the exact same type system object.

   * This method correctly handles aggregate as well as primitive analysis engines.

   * <p>

   * If you pass this method objects of type {@link AnalysisEngineDescription},

   * {@link CollectionReaderDescription}, {@link CasInitializerDescription}, or

   * {@link CasConsumerDescription}, it will not instantiate the components. It will just extract

   * the type system information from the descriptor. For any other kind of

   * {@link ResourceSpecifier}, it will call

   * {@link UIMAFramework#produceResource(org.apache.uima.resource.ResourceSpecifier, Map)}. For

   * example, if a {@link URISpecifier} is passed, a remote connection will be established and the

   * service will be queries for its metadata. An exception will be thrown if the connection can not

   * be opened.

   *

   * @param aComponentDescriptionsOrMetaData

   *          a collection of {@link ResourceSpecifier}, {@link ProcessingResourceMetaData},

   *          {@link TypeSystemDescription}, {@link FsIndexCollection}, or {@link TypePriorities}

   *          objects.

   * @param aTypeSystem

   *          type system to install in the CAS, null if none

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   * @param aResourceManager

   *          the resource manager to use to resolve import declarations within the metadata, and

   *          also to set the JCas ClassLoader for the new CAS

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(Collection aComponentDescriptionsOrMetaData, TypeSystem aTypeSystem,

          Properties aPerformanceTuningSettings, ResourceManager aResourceManager)

          throws ResourceInitializationException {

    // build a list of metadata objects

    List mdList = getMetaDataList(aComponentDescriptionsOrMetaData, aResourceManager);

    // extract TypeSystems, TypePriorities, and FsIndexes from metadata

    List typeSystems = new ArrayList();

    List typePriorities = new ArrayList();

    List fsIndexes = new ArrayList();

    Iterator it = mdList.iterator();

    while (it.hasNext()) {

      ProcessingResourceMetaData md = (ProcessingResourceMetaData) it.next();

      if (md.getTypeSystem() != null)

        typeSystems.add(md.getTypeSystem());

      if (md.getTypePriorities() != null)

        typePriorities.add(md.getTypePriorities());

      if (md.getFsIndexCollection() != null)

        fsIndexes.add(md.getFsIndexCollection());

    }

    // merge TypePriorities and FsIndexes

    TypePriorities aggTypePriorities = mergeTypePriorities(typePriorities, aResourceManager);

    FsIndexCollection aggIndexColl = mergeFsIndexes(fsIndexes, aResourceManager);

    if (aTypeSystem != null) // existing type system object was specified; use that

    {

      return createCas(aTypeSystem, aggTypePriorities, aggIndexColl.getFsIndexes(),

              aPerformanceTuningSettings, aResourceManager);

    } else {

      // no type system object specified; merge type system descriptions in metadata

      TypeSystemDescription aggTypeDesc = mergeTypeSystems(typeSystems);

      return createCas(aggTypeDesc, aggTypePriorities, aggIndexColl.getFsIndexes(),

              aPerformanceTuningSettings, aResourceManager);

    }

  }

  /**

   * Creates a new CAS instance that reuses an existing type system. Using this method allows

   * several CASes to all share the exact same type system object.

   *

   * @param aTypeSystem

   *          type system to install in the CAS

   * @param aTypePriorities

   *          type priorities to install in the CAS

   * @param aFsIndexes

   *          indexes to install in the CAS

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(TypeSystem aTypeSystem, TypePriorities aTypePriorities,

          FsIndexDescription[] aFsIndexes, Properties aPerformanceTuningSettings)

          throws ResourceInitializationException {

    return createCas(aTypeSystem, aTypePriorities, aFsIndexes, aPerformanceTuningSettings, null);

  }

  /**

   * Creates a new CAS instance that reuses an existing type system. Using this method allows

   * several CASes to all share the exact same type system object.

   *

   * @param aTypeSystem

   *          type system to install in the CAS

   * @param aTypePriorities

   *          type priorities to install in the CAS

   * @param aFsIndexes

   *          indexes to install in the CAS

   * @param aResourceManager

   *          resource manager, which is used to set the JCas ClassLoader for the new CAS

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  public static CAS createCas(TypeSystem aTypeSystem, TypePriorities aTypePriorities,

          FsIndexDescription[] aFsIndexes, Properties aPerformanceTuningSettings,

          ResourceManager aResourceManager) throws ResourceInitializationException {

    return doCreateCas(aTypeSystem, null, aTypePriorities, aFsIndexes, aPerformanceTuningSettings,

            aResourceManager);

  }

  /**

   * Method that does the work for creating a new CAS instance. Other createCas methods in this

   * class should all eventually call this method, so that the critical code is not duplicated in

   * more than one place.

   *

   * @param aTypeSystem

   *          an existing type sytsem to reuse in this CAS, null if none.

   * @param aTypeSystemDescription

   *          description of type system to use for this CAS. This is only used if aTypeSystem is

   *          null.

   * @param aTypePriorities

   *          type priorities to install in the CAS

   * @param aFsIndexes

   *          indexes to install in the CAS

   * @param aPerformanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS instance

   *

   * @throws ResourceInitializationException

   *           if CAS creation fails

   */

  private static CAS doCreateCas(TypeSystem aTypeSystem, TypeSystemDescription aTypeSystemDesc,

          TypePriorities aTypePriorities, FsIndexDescription[] aFsIndexes,

          Properties aPerformanceTuningSettings, ResourceManager aResourceManager)

          throws ResourceInitializationException {

    if (aResourceManager == null) {

      aResourceManager = UIMAFramework.newDefaultResourceManager();

    }

    // resolve imports

    try {

      if (aTypeSystemDesc != null) {

        aTypeSystemDesc.resolveImports(aResourceManager);

      }

      if (aTypePriorities != null) {

        aTypePriorities.resolveImports(aResourceManager);

      }

    } catch (InvalidXMLException e) {

      throw new ResourceInitializationException(e);

    }

    // get initial heap size

    String initialHeapSizeStr = null;

    if (aPerformanceTuningSettings != null) {

      initialHeapSizeStr = aPerformanceTuningSettings

              .getProperty(UIMAFramework.CAS_INITIAL_HEAP_SIZE);

    }

    // create CAS using either aTypeSystem or aTypeSystemDesc

    CASMgr casMgr;

    if (aTypeSystem != null) {

      if (initialHeapSizeStr != null) {

        casMgr = CASFactory.createCAS(Integer.parseInt(initialHeapSizeStr), aTypeSystem);

      } else {

        casMgr = CASFactory.createCAS(aTypeSystem);

      }

    } else // no TypeSystem to reuse - create a new one

    {

      if (initialHeapSizeStr != null) {

        casMgr = CASFactory.createCAS(Integer.parseInt(initialHeapSizeStr));

      } else {

        casMgr = CASFactory.createCAS();

      }

      // install type system

      setupTypeSystem(casMgr, aTypeSystemDesc);

      // Commit the type system

      ((CASImpl) casMgr).commitTypeSystem();

    }

    try {

      // install TypePriorities into CAS

      setupTypePriorities(casMgr, aTypePriorities);

      // install Built-in indexes into CAS

      casMgr.initCASIndexes();

    } catch (CASException e) {

      throw new ResourceInitializationException(e);

    }

    // install AnalysisEngine's custom indexes into CAS

    setupIndexes(casMgr, aFsIndexes);

    // Commit the index repository

    casMgr.getIndexRepositoryMgr().commit();

    // Set JCas ClassLoader

    if (aResourceManager.getExtensionClassLoader() != null) {

      casMgr.setJCasClassLoader(aResourceManager.getExtensionClassLoader());

    }

    return casMgr.getCAS().getView(CAS.NAME_DEFAULT_SOFA);

  }

  /**

   * Create a CAS from a CAS Definition.

   *

   * @param casDef

   *          completely describes the CAS to be created

   * @param performanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   *

   * @return a new CAS matching the given CasDefinition

   */

  public static CAS createCas(CasDefinition casDef, Properties performanceTuningSettings)

          throws ResourceInitializationException {

    return createCas(casDef.getTypeSystemDescription(), casDef.getTypePriorities(), casDef

            .getFsIndexDescriptions(), performanceTuningSettings, casDef.getResourceManager());

  }

  /**

   * Create a CAS from a CAS Definition, but reuse the provided TypeSystem object.

   *

   * @param casDef

   *          completely describes the CAS to be created

   * @param performanceTuningSettings

   *          Properties object containing framework performance tuning settings using key names

   *          defined on {@link UIMAFramework} interface

   * @param typeSystem

   *          type system object to reuse

   *

   * @return a new CAS matching the given CasDefinition

   */

  public static CAS createCas(CasDefinition casDef, Properties performanceTuningSettings,

          TypeSystem typeSystem) throws ResourceInitializationException {

    return createCas(typeSystem, casDef.getTypePriorities(), casDef.getFsIndexDescriptions(),

            performanceTuningSettings, casDef.getResourceManager());

  }

  /**

   * Installs a TypeSystem in a CAS.

   *

   * @param aCASMgr

   *          the <code>CASMgr</code> object whose type system is to be modified.

   * @param aTypeSystem

   *          desription of type system to install

   *

   * @throws ResourceInitializationException

   *           if an error occurs during modification of the type system

   */

  public static void setupTypeSystem(CASMgr aCASMgr, TypeSystemDescription aTypeSystem)

          throws ResourceInitializationException {

    TypeSystemMgr typeSystemMgr = aCASMgr.getTypeSystemMgr();

    if (aTypeSystem != null) {

      TypeDescription[] types = aTypeSystem.getTypes();

      if (types != null) {

        // add all Types first (so that we can handle forward references) - note

        // that it isn't guarnanteed that a supertype will occur in the Types list

        // before its subtype.

        // Build a linked list of type descriptions. We will make multiple passes

        // over this, adding types to the CAS and removing them from the linked

        // list. We continue until the list is empty or we cannot make any

        // progress.

        LinkedList typeList = new LinkedList();

        typeList.addAll(Arrays.asList(types));

        int numTypes = typeList.size();

        int lastNumTypes;

        LinkedList typesInOrderOfCreation = new LinkedList();

        do {

          lastNumTypes = numTypes;

          Iterator it = typeList.iterator();

          while (it.hasNext()) {

            TypeDescription curTypeDesc = (TypeDescription) it.next();

            String typeName = curTypeDesc.getName();

            // type does not exist - add it under the appropriate supertype

            String superTypeName = curTypeDesc.getSupertypeName();

            if (superTypeName == null) {

              throw new ResourceInitializationException(

                      ResourceInitializationException.NO_SUPERTYPE, new Object[] { typeName,

                          curTypeDesc.getSourceUrlString() });

            }

            Type supertype = typeSystemMgr.getType(superTypeName);

            if (supertype != null) {

              // supertype is defined, so add to CAS type system

              // check for special "enumerated types" that extend String

              if (curTypeDesc.getSupertypeName().equals(CAS.TYPE_NAME_STRING)) {

                AllowedValue[] vals = curTypeDesc.getAllowedValues();

                if (vals == null) {

                  throw new ResourceInitializationException(

                          ResourceInitializationException.MISSING_ALLOWED_VALUES, new Object[] {

                              typeName, curTypeDesc.getSourceUrlString() });

                }

                String[] valStrs = new String[vals.length];

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

                  valStrs[i] = vals[i].getString();

                }

                typeSystemMgr.addStringSubtype(typeName, valStrs);

              } else // a "normal" type

              {

                // make sure that allowed values are NOT specified for non-string subtypes

                if (curTypeDesc.getAllowedValues() != null

                        && curTypeDesc.getAllowedValues().length > 0) {

                  throw new ResourceInitializationException(

                          ResourceInitializationException.ALLOWED_VALUES_ON_NON_STRING_TYPE,

                          new Object[] { typeName, curTypeDesc.getSourceUrlString() });

                }

                typeSystemMgr.addType(typeName, supertype);

              }

              // remove from list of type descriptions and add it to the typesInOrderOfCreation list

              // for later processing

              it.remove();

              typesInOrderOfCreation.add(curTypeDesc);

            }

          }

          numTypes = typeList.size();

        } while (numTypes > 0 && numTypes != lastNumTypes);

        // we quit the above loop either when we've added all types or when

        // we went through the entire list without successfully finding any

        // supertypes. In the latter case, throw an exception

        if (numTypes > 0) {

          TypeDescription firstFailed = (TypeDescription) typeList.getFirst();

          throw new ResourceInitializationException(

                  ResourceInitializationException.UNDEFINED_SUPERTYPE, new Object[] {

                      firstFailed.getSupertypeName(), firstFailed.getName(),

                      firstFailed.getSourceUrlString() });

        }

        // now for each type, add its features. We add features to supertypes before subtypes. This

        // is done so that

        // if we have a duplicate feature name on both a supertype and a subtype, it is added to the

        // supertype and then

        // ignored when we get to the subtype. Although this is a dubious type system, we support it

        // for backwards

        // compatibility (but we might want to think about generating a warning).

        Iterator typeIter = typesInOrderOfCreation.iterator();

        while (typeIter.hasNext()) {

          TypeDescription typeDesc = (TypeDescription) typeIter.next();

          Type type = typeSystemMgr.getType(typeDesc.getName());

          // assert type != null;

          FeatureDescription[] features = typeDesc.getFeatures();

          if (features != null) {

            for (int j = 0; j < features.length; j++) {

              String featName = features[j].getName();

              String rangeTypeName = features[j].getRangeTypeName();

              Type rangeType = typeSystemMgr.getType(rangeTypeName);

              if (rangeType == null) {

                throw new ResourceInitializationException(

                        ResourceInitializationException.UNDEFINED_RANGE_TYPE, new Object[] {

                            rangeTypeName, featName, typeDesc.getName(),

                            features[j].getSourceUrlString() });

              }

              if (rangeType.isArray()) // TODO: also List?

              {

                // if an element type is specified, get the specific

                // array subtype for that element type

                String elementTypeName = features[j].getElementType();

                if (elementTypeName != null && elementTypeName.length() > 0) {

                  Type elementType = typeSystemMgr.getType(elementTypeName);

                  if (elementType == null) {

                    throw new ResourceInitializationException(

                            ResourceInitializationException.UNDEFINED_RANGE_TYPE, new Object[] {

                                elementTypeName, featName, typeDesc.getName(),

                                features[j].getSourceUrlString() });

                  }

                  rangeType = typeSystemMgr.getArrayType(elementType);

                }

              }

              Boolean multiRefAllowed = features[j].getMultipleReferencesAllowed();

              if (multiRefAllowed == null) {

                multiRefAllowed = Boolean.FALSE; // default to false if unspecified

              }

              typeSystemMgr.addFeature(featName, type, rangeType, multiRefAllowed.booleanValue());

            }

          }

        }

      }

    }

  }

  /**

   * Adds TypePriorities to a CAS.

   *

   * @param aCASMgr

   *          the <code>CASMgr</code> object to be modified

   * @param aTypePriorities

   *          description of the type priorities to add

   *

   * @throws CASException

   *           if an error occurs during type priority setup

   */

  public static void setupTypePriorities(CASMgr aCASMgr, TypePriorities aTypePriorities)

          throws ResourceInitializationException {

    if (aTypePriorities != null) {

      LinearTypeOrderBuilder typeOrderBuilder = aCASMgr.getIndexRepositoryMgr()

              .getDefaultOrderBuilder();

      TypePriorityList[] priorityLists = aTypePriorities.getPriorityLists();

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

        // check that all types exist. This error would be caught in

        // typeOrderBuilder.getOrder(), but that's too late to indicate

        // the location of the faulty descriptor in the error message.

        String[] typeList = priorityLists[i].getTypes();

        for (int j = 0; j < typeList.length; j++) {

          if (aCASMgr.getTypeSystemMgr().getType(typeList[j]) == null) {

            throw new ResourceInitializationException(

                    ResourceInitializationException.UNDEFINED_TYPE_FOR_PRIORITY_LIST, new Object[] {

                        typeList[j], priorityLists[i].getSourceUrlString() });

          }

        }

        try {

          typeOrderBuilder.add(priorityLists[i].getTypes());

        } catch (CASException e) {

          // typically caused by a cycle in the priorities - the caused-by message

          // will clarify.

          throw new ResourceInitializationException(

                  ResourceInitializationException.INVALID_TYPE_PRIORITIES,

                  new Object[] { priorityLists[i].getSourceUrlString() }, e);

        }

      }

    }

  }

  /**

   * Adds FeatureStructure indexes to a CAS.

   *

   * @param aCASMgr

   *          the <code>CASMgr</code> object to be modified

   * @param aIndexes

   *          descriptions of the indexes to add

   *

   * @throws ResourceInitializationException

   *           if an error occurs during index creation

   */

  public static void setupIndexes(CASMgr aCASMgr, FsIndexDescription[] aIndexes)

          throws ResourceInitializationException {

    if (aIndexes != null) {

      TypeSystemMgr tsm = aCASMgr.getTypeSystemMgr();

      FSIndexRepositoryMgr irm = aCASMgr.getIndexRepositoryMgr();

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

        int kind = FSIndex.SORTED_INDEX;

        String kindStr = aIndexes[i].getKind();

        if (kindStr != null) {

          if (kindStr.equals(FsIndexDescription.KIND_BAG))

            kind = FSIndex.BAG_INDEX;

          else if (kindStr.equals(FsIndexDescription.KIND_SET))

            kind = FSIndex.SET_INDEX;

          else if (kindStr.equals(FsIndexDescription.KIND_SORTED))

            kind = FSIndex.SORTED_INDEX;

        }

        Type type = tsm.getType(aIndexes[i].getTypeName());

        if (type == null) {

          throw new ResourceInitializationException(

                  ResourceInitializationException.UNDEFINED_TYPE_FOR_INDEX, new Object[] {

                      aIndexes[i].getTypeName(), aIndexes[i].getLabel(),

                      aIndexes[i].getSourceUrlString() });

        }

        FSIndexComparator comparator = irm.createComparator();

        comparator.setType(type);

        FsIndexKeyDescription[] keys = aIndexes[i].getKeys();

        if (keys != null) {

          for (int j = 0; j < keys.length; j++) {

            if (keys[j].isTypePriority()) {

              comparator.addKey(irm.getDefaultTypeOrder(), FSIndexComparator.STANDARD_COMPARE);

            } else {

              Feature feature = type.getFeatureByBaseName(keys[j].getFeatureName());

              if (feature == null) {

                throw new ResourceInitializationException(

                        ResourceInitializationException.INDEX_KEY_FEATURE_NOT_FOUND, new Object[] {

                            keys[j].getFeatureName(), aIndexes[i].getLabel(),

                            aIndexes[i].getSourceUrlString() });

              }

              comparator.addKey(feature, keys[j].getComparator());

            }

          }

        }

        irm.createIndex(comparator, aIndexes[i].getLabel(), kind);

      }

    }

  }

  /**

   * Extracts a TypeSystem definition from a CasData.

   *

   * @param aCasData

   *          the CAS Data from which to extract the type system

   *

   * @return a description of a TypeSystem to which the CAS Data conforms

   */

  public static TypeSystemDescription convertData2TypeSystem(CasData aCasData) {

    TypeSystemDescription result = UIMAFramework.getResourceSpecifierFactory()

            .createTypeSystemDescription();

    Iterator iter = aCasData.getFeatureStructures();

    ArrayList typesArr = new ArrayList();

    while (iter.hasNext()) {

      FeatureStructure casFS = (FeatureStructure) iter.next();

      TypeDescription newType = UIMAFramework.getResourceSpecifierFactory().createTypeDescription();

      newType.setName(casFS.getType());

      newType.setSupertypeName("uima.tcas.annotation");

      newType.setDescription("CasData Type");

      String features[] = casFS.getFeatureNames();

      if (features != null) {

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

          String featName = features[i];

          String rangeName = "";

          String description = "";

          PrimitiveValue pVal = (PrimitiveValue) casFS.getFeatureValue(featName);

          if (pVal.get().getClass().getName().equals("java.lang.String")) {

            System.out.println(" the feature is a String ");

            rangeName = "uima.cas.String";

            description = " featue of the casDataType";

          }

          newType.addFeature(featName, description, rangeName);

        }

      }

      typesArr.add(newType);

    }

    TypeDescription td[] = new TypeDescription[typesArr.size()];

    for (int j = 0; j < typesArr.size(); j++) {

      td[j] = (TypeDescription) typesArr.get(j);

    }

    result.setTypes(td);

    return result;

  }

  /**

   * Merges several TypeSystemDescriptions into one. Also resolves imports in the

   * TypeSystemDescription objects.

   *

   * @param aTypeSystems

   *          a collection of TypeSystems to be merged

   *

   * @return a new TypeSystemDescription that is the result of merging all of the type systems

   *         together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static TypeSystemDescription mergeTypeSystems(Collection aTypeSystems)

          throws ResourceInitializationException {

    return mergeTypeSystems(aTypeSystems, UIMAFramework.newDefaultResourceManager());

  }

  /**

   * Merges several TypeSystemDescriptions into one. Also resolves imports in the

   * TypeSystemDescription objects.

   *

   * @param aTypeSystems

   *          a collection of TypeSystems to be merged

   * @param aResourceManager

   *          Resource Manager to use to locate type systems imported by name

   *

   * @return a new TypeSystemDescription that is the result of merging all of the type systems

   *         together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static TypeSystemDescription mergeTypeSystems(Collection aTypeSystems,

          ResourceManager aResourceManager) throws ResourceInitializationException {

    return mergeTypeSystems(aTypeSystems, aResourceManager, null);

  }

  /**

   * Merges several TypeSystemDescriptions into one. Also resolves imports in the

   * TypeSystemDescription objects.

   * <p>

   * This version of this method takes an argument <code>aOutputMergedTypes</code>, which

   * this method will populate with the names and descriptor locations of any types whose definitions

   * have been merged from multiple non-identical sources. That is, types that are declared

   * more than once, with different (but compatible) sets of features in each declaration,

   * or with different (but compatible) supertypes.

   *

   * @param aTypeSystems

   *          a collection of TypeSystems to be merged

   * @param aResourceManager

   *          Resource Manager to use to locate type systems imported by name

   * @param aOutputMergedTypes

   *          A Map that this method will populate with information about the set of types

   *          whose definitions were merged from multiple non-identical sources. The keys in

   *          the Map will be the type names (Strings) and the values will be

   *          {link Set}s containing Descriptor URLs (Strings) where those types are

   *          declared. You may pass null if you are not interested in this information.

   *

   * @return a new TypeSystemDescription that is the result of merging all of the type systems

   *         together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static TypeSystemDescription mergeTypeSystems(Collection aTypeSystems,

          ResourceManager aResourceManager, Map aOutputMergedTypes)

          throws ResourceInitializationException {

    // create the type system into which we are merging

    TypeSystemDescription result = UIMAFramework.getResourceSpecifierFactory()

            .createTypeSystemDescription();

    // also build a Map from Type names to Types

    Map typeNameMap = new HashMap();

    // Now iterate through all type systems - if a new type is found, add it.

    // If an existing type is found, merge features.

    Iterator it = aTypeSystems.iterator();

    while (it.hasNext()) {

      TypeSystemDescription ts = (TypeSystemDescription) it.next();

      if (ts != null) {

        try {

          ts.resolveImports(aResourceManager);

        } catch (InvalidXMLException e) {

          throw new ResourceInitializationException(e);

        }

        TypeDescription[] types = ts.getTypes();

        if (types != null) {

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

            String typeName = types[i].getName();

            TypeDescription existingType = (TypeDescription) typeNameMap.get(typeName);

            if (existingType == null) {

              // create new type

              existingType = result.addType(types[i].getName(), types[i].getDescription(), types[i]

                      .getSupertypeName());

              existingType.setAllowedValues(types[i].getAllowedValues());

              existingType.setSourceUrl(types[i].getSourceUrl());

              typeNameMap.put(types[i].getName(), existingType);

              FeatureDescription[] features = types[i].getFeatures();

              if (features != null) {

                mergeFeatures(existingType, types[i].getFeatures());

              }

            } else {

              // type already existed - check that supertypes are compatible

              String supertypeName = types[i].getSupertypeName();

              String existingSupertypeName = existingType.getSupertypeName();

              if (!existingSupertypeName.equals(supertypeName)) {

                // supertypes are not identical - check if one subsumes the other

                if (subsumes(existingSupertypeName, supertypeName, typeNameMap)) {

                  // existing supertype subsumes newly specified supertype -

                  // reset supertype to the new, more specific type

                  existingType.setSupertypeName(supertypeName);

                  // report that a merge occurred

                  reportMerge(aOutputMergedTypes, types[i], existingType);

                } else if (subsumes(supertypeName, existingSupertypeName, typeNameMap)) {

                  // newly specified supertype subsumes old type, this is OK and we don't

                  // need to do anything except report this

                  reportMerge(aOutputMergedTypes, types[i], existingType);

                } else {

                  // error

                  throw new ResourceInitializationException(

                          ResourceInitializationException.INCOMPATIBLE_SUPERTYPES, new Object[] {

                              typeName, supertypeName, existingSupertypeName,

                              types[i].getSourceUrlString() });

                }

              }

              // merge features

              int prevNumFeatures = existingType.getFeatures().length;

              FeatureDescription[] features = types[i].getFeatures();

              if (features != null) {

                mergeFeatures(existingType, types[i].getFeatures());

                // if feature-merged occurred, the number of features on the type will have

                // changed. Report this by adding to the aOutputMergedTypeNames collection.

                if (existingType.getFeatures().length != prevNumFeatures) {

                  reportMerge(aOutputMergedTypes, types[i], existingType);

                }

              }

            }

          }

        }

      }

    }

    return result;

  }

  /**

   * Utility method for populating the aOutputMergedTypes argument in the

   * mergeTypeSystems method.

   * @param aOutputMergedTypes Map to populate

   * @param currentType TypeDescription currently being processed

   * @param existingType TypeDescription that already existed for the same name

   */

  private static void reportMerge(Map aOutputMergedTypes, TypeDescription currentType,

          TypeDescription existingType) {

    if (aOutputMergedTypes != null) {

      String typeName = currentType.getName();

      Set descriptorUrls = (Set)aOutputMergedTypes.get(typeName);

      if (descriptorUrls == null) {

        descriptorUrls = new TreeSet();

        descriptorUrls.add(existingType.getSourceUrlString());

        descriptorUrls.add(currentType.getSourceUrlString());

        aOutputMergedTypes.put(typeName, descriptorUrls);

      }

      else {

        descriptorUrls.add(currentType.getSourceUrlString());

      }

    }

  }

  /**

   * Merges the Type Systems of each component within an aggregate Analysis Engine, producing a

   * single combined Type System.

   *

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   *

   * @return a new TypeSystemDescription that is the result of merging all of the delegate AE type

   *         systems together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static TypeSystemDescription mergeDelegateAnalysisEngineTypeSystems(

          AnalysisEngineDescription aAggregateDescription) throws ResourceInitializationException {

    return mergeDelegateAnalysisEngineTypeSystems(aAggregateDescription, UIMAFramework

            .newDefaultResourceManager());

  }

  /**

   * Merges the Type Systems of each component within an aggregate Analysis Engine, producing a

   * single combined Type System.

   * <p>

   * This version of this method takes an argument <code>aOutputMergedTypeNames</code>, to which

   * this method will add the names of any types whose definitions have been merged from multiple

   * non-identical sources. That is, types that are declared more than once, with different (but

   * compatible) sets of features in each declaration, or with different (but compatible)

   * supertypes.

   *

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   * @param aResourceManager

   *          ResourceManager instance used to resolve imports

   *

   * @return a new TypeSystemDescription that is the result of merging all of the delegate AE type

   *         systems together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static TypeSystemDescription mergeDelegateAnalysisEngineTypeSystems(

          AnalysisEngineDescription aAggregateDescription, ResourceManager aResourceManager)

          throws ResourceInitializationException {

    return mergeDelegateAnalysisEngineTypeSystems(aAggregateDescription, aResourceManager, null);

  }

  /**

   * Merges the Type Systems of each component within an aggregate Analysis Engine, producing a

   * single combined Type System.

   * <p>

   * This version of this method takes an argument <code>aOutputMergedTypes</code>, which

   * this method will populate with the names and descriptor locations of any types whose definitions

   * have been merged from multiple non-identical sources. That is, types that are declared

   * more than once, with different (but compatible) sets of features in each declaration,

   * or with different (but compatible) supertypes.

   * 

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   * @param aResourceManager

   *          ResourceManager instance used to resolve imports

   * @param aOutputMergedTypes

   *          A Map that this method will populate with information about the set of types

   *          whose definitions were merged from multiple non-identical sources. The keys in

   *          the Map will be the type names (Strings) and the values will be

   *          {link Set}s containing Descriptor URLs (Strings) where those types are

   *          declared. You may pass null if you are not interested in this information.

   *    *

   * @return a new TypeSystemDescription that is the result of merging all of the delegate AE type

   *         systems together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static TypeSystemDescription mergeDelegateAnalysisEngineTypeSystems(

          AnalysisEngineDescription aAggregateDescription, ResourceManager aResourceManager,

          Map aOutputMergedTypes) throws ResourceInitializationException {

    // expand the aggregate AE description into the individual delegates

    ArrayList l = new ArrayList();

    l.add(aAggregateDescription);

    List mdList = getMetaDataList(l, aResourceManager);

    // extract type systems and merge

    List typeSystems = new ArrayList();

    Iterator it = mdList.iterator();

    while (it.hasNext()) {

      ProcessingResourceMetaData md = (ProcessingResourceMetaData) it.next();

      if (md.getTypeSystem() != null)

        typeSystems.add(md.getTypeSystem());

    }

    return mergeTypeSystems(typeSystems, aResourceManager, aOutputMergedTypes);

  }

  /**

   * Merges a List of FsIndexCollections into a single FsIndexCollection object.

   *

   * @param aFsIndexCollections

   *          list of FsIndexCollection objects

   * @param aResourceManager

   *          ResourceManager instance to use to resolve imports

   *

   * @return a merged FsIndexCollection object

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static FsIndexCollection mergeFsIndexes(List aFsIndexCollections,

          ResourceManager aResourceManager) throws ResourceInitializationException {

    Map aggIndexes = new HashMap();

    Iterator it = aFsIndexCollections.iterator();

    while (it.hasNext()) {

      FsIndexCollection indexColl = (FsIndexCollection) it.next();

      if (indexColl != null) {

        try {

          indexColl.resolveImports(aResourceManager);

        } catch (InvalidXMLException e) {

          throw new ResourceInitializationException(e);

        }

        FsIndexDescription[] indexes = indexColl.getFsIndexes();

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

          // does an index with this label already exist?

          FsIndexDescription duplicateIndex = (FsIndexDescription) aggIndexes.get(indexes[i]

                  .getLabel());

          if (duplicateIndex == null) {

            // no, so add it

            aggIndexes.put(indexes[i].getLabel(), indexes[i]);

          } else if (!duplicateIndex.equals(indexes[i])) {

            // index with same label exists, they better be equal!

            throw new ResourceInitializationException(

                    ResourceInitializationException.DUPLICATE_INDEX_NAME, new Object[] {

                        duplicateIndex.getLabel(), duplicateIndex.getSourceUrlString(),

                        indexes[i].getSourceUrlString() });

          }

        }

      }

    }

    // convert index map to FsIndexCollection

    FsIndexCollection aggIndexColl = UIMAFramework.getResourceSpecifierFactory()

            .createFsIndexCollection();

    Collection indexes = aggIndexes.values();

    FsIndexDescription[] indexArray = new FsIndexDescription[indexes.size()];

    indexes.toArray(indexArray);

    aggIndexColl.setFsIndexes(indexArray);

    return aggIndexColl;

  }

  /**

   * Merges the FS Index Collections of each component within an aggregate Analysis Engine,

   * producing a single combined FS Index Collection.

   *

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   *

   * @return a new FsIndexCollection that is the result of merging all of the delegate AE

   *         FsIndexCollections together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static FsIndexCollection mergeDelegateAnalysisEngineFsIndexCollections(

          AnalysisEngineDescription aAggregateDescription) throws ResourceInitializationException {

    return mergeDelegateAnalysisEngineFsIndexCollections(aAggregateDescription, UIMAFramework

            .newDefaultResourceManager());

  }

  /**

   * Merges the FS Index Collections of each component within an aggregate Analysis Engine,

   * producing a single combined FS Index Collection.

   *

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   * @param aResourceManager

   *          ResourceManager instance used to resolve imports

   *

   * @return a new FsIndexCollection that is the result of merging all of the delegate AE

   *         FsIndexCollections together

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */

  public static FsIndexCollection mergeDelegateAnalysisEngineFsIndexCollections(

          AnalysisEngineDescription aAggregateDescription, ResourceManager aResourceManager)

          throws ResourceInitializationException {

    // expand the aggregate AE description into the individual delegates

    ArrayList l = new ArrayList();

    l.add(aAggregateDescription);

    List mdList = getMetaDataList(l, aResourceManager);

    // extract FsIndexCollections and merge

    List fsIndexes = new ArrayList();

    Iterator it = mdList.iterator();

    while (it.hasNext()) {

      ProcessingResourceMetaData md = (ProcessingResourceMetaData) it.next();

      if (md.getFsIndexCollection() != null)

        fsIndexes.add(md.getFsIndexCollection());

    }

    return mergeFsIndexes(fsIndexes, aResourceManager);

  }

  /**

   * Merges a List of TypePriorities into a single TypePriorities object.

   *

   * @param aTypePriorities

   *          list of TypePriorities objects

   * @param aResourceManager

   *          ResourceManager instance to use to resolve imports

   *

   * @return a merged TypePriorities object

   * @throws ResourceInitializationException

   *           if an import could not be resolved

   */

  public static TypePriorities mergeTypePriorities(List aTypePriorities,

          ResourceManager aResourceManager) throws ResourceInitializationException {

    TypePriorities aggTypePriorities = UIMAFramework.getResourceSpecifierFactory()

            .createTypePriorities();

    Iterator it = aTypePriorities.iterator();

    while (it.hasNext()) {

      TypePriorities tp = (TypePriorities) it.next();

      try {

        tp.resolveImports(aResourceManager);

      } catch (InvalidXMLException e) {

        throw new ResourceInitializationException(e);

      }

      TypePriorityList[] pls = tp.getPriorityLists();

      if (pls != null) {

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

          aggTypePriorities.addPriorityList(pls[i]);

        }

      }

    }

    return aggTypePriorities;

  }

  /**

   * Merges the Type Priorities of each component within an aggregate Analysis Engine, producing a

   * single combined TypePriorities object.

   *

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   *

   * @return a new TypePriorities object that is the result of merging all of the delegate AE

   *         TypePriorities together

   *

   * @throws ResourceInitializationException

   *           if an incompatibility exists

   */

  public static TypePriorities mergeDelegateAnalysisEngineTypePriorities(

          AnalysisEngineDescription aAggregateDescription) throws ResourceInitializationException {

    return mergeDelegateAnalysisEngineTypePriorities(aAggregateDescription, UIMAFramework

            .newDefaultResourceManager());

  }

  /**

   * Merges the Type Priorities of each component within an aggregate Analysis Engine, producing a

   * single combined TypePriorities object.

   *

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   * @param aResourceManager

   *          ResourceManager instance used to resolve imports

   *

   * @return a new TypePriorities object that is the result of merging all of the delegate AE

   *         TypePriorities together

   *

   * @throws ResourceInitializationException

   *           if an incompatibility exists

   */

  public static TypePriorities mergeDelegateAnalysisEngineTypePriorities(

          AnalysisEngineDescription aAggregateDescription, ResourceManager aResourceManager)

          throws ResourceInitializationException {

    // expand the aggregate AE description into the individual delegates

    ArrayList l = new ArrayList();

    l.add(aAggregateDescription);

    List mdList = getMetaDataList(l, aResourceManager);

    // extract TypePriorities and merge

    List typePriorities = new ArrayList();

    Iterator it = mdList.iterator();

    while (it.hasNext()) {

      ProcessingResourceMetaData md = (ProcessingResourceMetaData) it.next();

      if (md.getTypePriorities() != null)

        typePriorities.add(md.getTypePriorities());

    }

    return mergeTypePriorities(typePriorities, aResourceManager);

  }

 

  /**

   * Merges the Type Systems, Type Priorities, and FS Indexes of each component within an

   * aggregate Analysis Engine.

   * <p>

   * This version of this method takes an argument <code>aOutputMergedTypes</code>, which

   * this method will populate with the names and descriptor locations of any types whose definitions

   * have been merged from multiple non-identical sources. That is, types that are declared

   * more than once, with different (but compatible) sets of features in each declaration,

   * or with different (but compatible) supertypes.

   * 

   * @param aAggregateDescription

   *          an aggregate Analysis Engine description

   * @param aResourceManager

   *          ResourceManager instance used to resolve imports

   * @param aOutputMergedTypes

   *          A Map that this method will populate with information about the set of types

   *          whose definitions were merged from multiple non-identical sources.  That is,

   *          types that are declared more than once, with different (but compatible) sets

   *          of features in each declaration, or with different (but compatible) supertypes.

   *          The keys in the Map will be the type names (Strings) and the values will be

   *          {link Set}s containing Descriptor URLs (Strings) where those types are

   *          declared. You may pass null if you are not interested in this information.

   *  @param aOutputFailedRemotes

   *          If this paramter is non-null, and if a remote AE could not be contacted, then

   *          an entry will be added to this map.  The key will be the context name (e.g.,

   *          /myDelegate1/nestedRemoteDelegate) of the failed remote, and the value will be

   *          the Exception that occurred.  If this parameter is null, an exception will be thrown

   *          if a remote AE could not be contacted.

   * 

   * @return an object containing the merged TypeSystem, TypePriorities, and FS Index definitions.

   *

   * @throws ResourceInitializationException

   *           if an incompatibiliy exists or if an import could not be resolved

   */ 

  public static ProcessingResourceMetaData mergeDelegateAnalysisEngineMetaData(

          AnalysisEngineDescription aAggregateDescription, ResourceManager aResourceManager,

          Map aOutputMergedTypes, Map aOutputFailedRemotes) throws ResourceInitializationException {

    // expand the aggregate AE description into the individual delegates

    ArrayList l = new ArrayList();

    l.add(aAggregateDescription);

    List mdList = getMetaDataList(l, aResourceManager, aOutputFailedRemotes);

   

    ProcessingResourceMetaData result =

      UIMAFramework.getResourceSpecifierFactory().createProcessingResourceMetaData();