/** \file taespecifier.cpp .
-----------------------------------------------------------------------------

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

-----------------------------------------------------------------------------

   Description: Resource Specifier Classes for Text Analysis Engines

-----------------------------------------------------------------------------


   01/30/2003  Initial creation

-------------------------------------------------------------------------- */
// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------

#include "uima/pragmas.hpp" //must be first to surpress warnings
#include "uima/err_ids.h"
#include "uima/msg.h"


#include "uima/taespecifierbuilder.hpp"
#include "uima/typesystemdescription.hpp"
#include "uima/capability.hpp"
#include "uima/config_param.hpp"
#include "uima/taespecifier.hpp"
#include "uima/caswriter_abase.hpp"
using namespace std;
namespace uima {
  UIMA_EXC_CLASSIMPLEMENT(ConfigParamLookupException, ConfigException);

  AnalysisEngineMetaData::~AnalysisEngineMetaData() {
    delete iv_pTypeSystemDesc;
    delete iv_pFlowConstraints;
    if (iv_pOperationalProperties != 0) {
      delete iv_pOperationalProperties;
    }
    size_t i=0;
    for (i=0; i < iv_capabilities.size(); i++) {
      delete iv_capabilities[i];
    }
    for (i=0; i < iv_indexDescs.size(); i++) {
      delete iv_indexDescs[i];
    }
    for (i=0; i < iv_vecpTypePriorities.size(); i++) {
      delete iv_vecpTypePriorities[i];
    }
    for (i=0; i < iv_fsindexImportDescs.size(); i++) {
      delete iv_fsindexImportDescs[i];
    }
    for (i=0; i < iv_typepriorityImportDescs.size(); i++) {
      delete iv_typepriorityImportDescs[i];
    }

  }

  void AnalysisEngineMetaData::validate() {
    size_t i=0;
    //validate the type system
    //validate(*aeMetadata.getTypeSystemDescription());
    getTypeSystemDescription()->validate();

    //validate the capabilities
    AnalysisEngineMetaData::TyVecpCapabilities capabilities = getCapabilites();
    for (i=0; i<capabilities.size(); i++) {
		if ( !(EXISTS(capabilities[i])) ) {
			UIMA_EXC_THROW_NEW(ValidationException,
                           UIMA_ERR_CONFIG_OBJECT_NOT_FOUND,
                           ErrorMessage(UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC),
                           UIMA_MSG_ID_EXCON_CHECKING_CAPABILITY_SPEC,
                           ErrorInfo::unrecoverable);
		}
    }

    //validate the index descriptions
    AnalysisEngineMetaData::TyVecpFSIndexDescriptions indexDescs = getFSIndexDescriptions();
    vector <icu::UnicodeString> indexLabels;
    for (i=0; i<indexDescs.size(); i++) {
      if ( !(EXISTS(indexDescs[i])) ){
			UIMA_EXC_THROW_NEW(ValidationException,
                           UIMA_ERR_CONFIG_OBJECT_NOT_FOUND,
                           ErrorMessage(UIMA_MSG_ID_EXC_INVALID_INDEX_OBJECT, indexLabels[i]),
                           UIMA_MSG_ID_EXCON_CHECKING_INDEX_DEFINITION,
                           ErrorInfo::unrecoverable);
	  }
      indexLabels.push_back((*indexDescs[i]).getLabel());
    }

    //check uniqueness of the index description labels
    for (i=0; i<indexLabels.size(); i++) {
      if ( countValues(indexLabels.begin(), indexLabels.end(), indexLabels[i]) != 1) {

        UIMA_EXC_THROW_NEW(ValidationException,
                           UIMA_ERR_CONFIG_DUPLICATE_INDEX_LABEL,
                           ErrorMessage(UIMA_MSG_ID_EXC_DUPLICATE_INDEX_LABEL, indexLabels[i]),
                           UIMA_MSG_ID_EXCON_CHECKING_INDEX_DEFINITION,
                           ErrorInfo::unrecoverable);
      }
    }

    //validate the configuration parameters

    //make sure that there's a value for each mandatory configuration parameter
    const vector <icu::UnicodeString> groupNames = getConfigurationGroupNames();
    for (i=0; i < groupNames.size(); i++) {
      const vector <const ConfigurationParameter *> params = getConfigurationParameters(groupNames[i]);
      for (size_t j=0; j < params.size(); j++) {
        if (params[j]->isMandatory()) {
          NameValuePair * nvPair = getNameValuePair(groupNames[i], params[j]->getName(),
                                   getSearchStrategy());
          if (! EXISTS(nvPair)) {
            if (hasGroups()) {
              ErrorMessage err(UIMA_MSG_ID_EXC_NO_VALUE_FOR_MANDATORY_PARAM_IN_GROUP);
              err.addParam(groupNames[i]);
              err.addParam(params[j]->getName());
              UIMA_EXC_THROW_NEW(ValidationException,
                                 UIMA_ERR_CONFIG_NO_VALUE_FOR_MANDATORY_PARAM_IN_GROUP,
                                 err,
                                 UIMA_MSG_ID_EXCON_VALIDATE_TAE_SPEC,
                                 ErrorInfo::unrecoverable);
            } else {
              ErrorMessage err(UIMA_MSG_ID_EXC_NO_VALUE_FOR_MANDATORY_PARAM);
              err.addParam(params[j]->getName());
              UIMA_EXC_THROW_NEW(ValidationException,
                                 UIMA_ERR_CONFIG_NO_VALUE_FOR_MANDATORY_PARAM,
                                 err,
                                 UIMA_MSG_ID_EXCON_VALIDATE_TAE_SPEC,
                                 ErrorInfo::unrecoverable);

            }
          }
        }
      }
    }
  }

  void AnalysisEngineMetaData::commit() {
    if (EXISTS(iv_pTypeSystemDesc)) {
      iv_pTypeSystemDesc->commit();
    }
    if (EXISTS(iv_pFlowConstraints)) {
      iv_pFlowConstraints->commit();
    }
    TyConfigGroup::iterator ite;
    for (ite = iv_configurationGroups.begin(); ite != iv_configurationGroups.end(); ite++) {
      (*ite).second.commit();
    }
    size_t i;
    for (i=0; i < iv_capabilities.size(); i++) {
      iv_capabilities[i]->commit();
    }
    for (i=0; i < iv_indexDescs.size(); i++) {
      iv_indexDescs[i]->commit();
    }
    for (i=0; i < iv_vecpTypePriorities.size(); i++) {
      iv_vecpTypePriorities[i]->commit();
    }
    if (hasDefaultGroup()) {
      TyConfigGroup::const_iterator ite = iv_configurationGroups.find(iv_defaultGroup);
      if (ite == iv_configurationGroups.end()) {
        iv_configurationGroups [iv_defaultGroup] = ConfigurationGroup();
      }
    }
    iv_bIsModifiable = false;
  }

  /**
  * Note: The configuration group is set during <code>commit</code>, if it doesn't exist already.
  * If we set it here, <code>addConfigurationGroup</code> throws an exception when it encounters
  * the group again.
  **/
  TyErrorId AnalysisEngineMetaData::setDefaultGroupName(const icu::UnicodeString & groupName) {
    if (! isModifiable()) {
      return UIMA_ERR_CONFIG_OBJECT_COMITTED;
    }
    iv_hasDefaultGroup = true;
    iv_defaultGroup = groupName;
    return UIMA_ERR_NONE;
  }


  TyErrorId AnalysisEngineMetaData::addConfigurationGroup(const icu::UnicodeString & groupName) {
    if (! isModifiable()) {
      return UIMA_ERR_CONFIG_OBJECT_COMITTED;
    }
    TyConfigGroup::iterator ite = iv_configurationGroups.find(groupName);
    if (ite == iv_configurationGroups.end()) {
      iv_configurationGroups [groupName] = ConfigurationGroup();
      return UIMA_ERR_NONE;
    } else {
      UIMA_EXC_THROW_NEW(DuplicateConfigElemException,
                         UIMA_ERR_CONFIG_DUPLICATE_GROUP,
                         UIMA_MSG_ID_EXC_CONFIG_DUPLICATE_GROUP,
                         ErrorMessage(UIMA_MSG_ID_EXC_CONFIG_DUPLICATE_GROUP, groupName),
                         ErrorInfo::recoverable);
    }
  }

  TyErrorId AnalysisEngineMetaData::addConfigurationParameter(const icu::UnicodeString & groupName,
      ConfigurationParameter * param) {
    if (! isModifiable()) {
      return UIMA_ERR_CONFIG_OBJECT_COMITTED;
    }

    if (groupName.compare(CONFIG_GROUP_NAME_WHEN_NO_GROUPS) != 0) {
      iv_hasGroups = true;
    }
    TyConfigGroup::iterator ite = iv_configurationGroups.find(groupName);
    if (ite == iv_configurationGroups.end()) {
      iv_configurationGroups [groupName] = ConfigurationGroup();
      ite = iv_configurationGroups.find(groupName);
    }
    ConfigurationGroup & group = (*ite).second;
    if (isParameterDefined(groupName, param->getName(), "")) {
      ErrorMessage msg(UIMA_MSG_ID_EXC_CONFIG_DUPLICATE_CONFIG_PARAM);
      msg.addParam(param->getName());
      UIMA_EXC_THROW_NEW(DuplicateConfigElemException,
                         UIMA_ERR_CONFIG_DUPLICATE_CONFIG_PARAM,
                         UIMA_MSG_ID_EXC_CONFIG_DUPLICATE_CONFIG_PARAM,
                         msg,
                         ErrorInfo::recoverable);
    }
    return group.addConfigurationParameter(param);
  }

  void AnalysisEngineMetaData::addNameValuePair(const icu::UnicodeString & groupName,
      NameValuePair * nvPair) {
    if (! isParameterDefined(groupName, nvPair->getName(), "")) {
      const icu::UnicodeString & paramName = nvPair->getName();
      if (hasGroups()) {
        ErrorMessage msg(UIMA_MSG_ID_EXC_CONFIG_PARAM_NOT_DEFINED_IN_GROUP);
        msg.addParam(paramName);
        msg.addParam(groupName);
        UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                           UIMA_ERR_CONFIG_PARAM_NOT_DEFINED_IN_GROUP,
                           msg,
                           ErrorMessage(UIMA_MSG_ID_EXCON_CONFIG_PARAM_SEARCH, paramName),
                           ErrorInfo::recoverable);
      } else {
        UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                           UIMA_ERR_CONFIG_PARAM_NOT_DEFINED,
                           ErrorMessage(UIMA_MSG_ID_EXC_CONFIG_PARAM_NOT_DEFINED, paramName),
                           ErrorMessage(UIMA_MSG_ID_EXCON_CONFIG_PARAM_SEARCH, paramName),
                           ErrorInfo::recoverable);
      }
    }
    TyConfigSettings::iterator ite = iv_configurationSettings.find(groupName);
    if (ite == iv_configurationSettings.end()) {
      iv_configurationSettings [groupName] = SettingsForGroup();
      ite = iv_configurationSettings.find(groupName);
    }
    SettingsForGroup & settings = (*ite).second;
    settings.addNameValuePair(nvPair);
  }

  NameValuePair * AnalysisEngineMetaData::getNameValuePairPtr(const icu::UnicodeString & groupName,
      const icu::UnicodeString & paramName) {
    TyConfigSettings::iterator ite = iv_configurationSettings.find(groupName);
    if (ite == iv_configurationSettings.end()) { // the group doesn't exist
      return NULL;
    }
    SettingsForGroup & settings = (*ite).second;
    return settings.getNameValuePair(paramName);
  }

  const icu::UnicodeString & AnalysisEngineMetaData::getGroupNameWhenNotSpec() const {
    if (hasGroups()) {
      if (hasDefaultGroup()) {
        return getDefaultGroupName();
      } else {
        UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                           UIMA_ERR_CONFIG_NO_DEFAULT_GROUP_DEFINED,
                           UIMA_MSG_ID_EXC_CONFIG_NO_DEFAULT_GROUP_DEFINED,
                           UIMA_MSG_ID_EXC_CONFIG_NO_DEFAULT_GROUP_DEFINED,
                           ErrorInfo::recoverable);
      }
    } else {
      return CONFIG_GROUP_NAME_WHEN_NO_GROUPS;
    }
  }


  /**
  * This behavior ensures that an aggregate TAESpecifier that contains groups can
  * redefine parameters for TAESpecifiers that don't contain a group:
  * the aggregate has to define the parameter in its default group.
  **/
  NameValuePair * AnalysisEngineMetaData::getNameValuePair(const icu::UnicodeString & paramName,
      const icu::UnicodeString & ancKey) {
    return getNameValuePair(getGroupNameWhenNotSpec(), paramName, getSearchStrategy(), ancKey);
  }

  NameValuePair *  AnalysisEngineMetaData::getNameValuePair(const icu::UnicodeString & groupName,
      const icu::UnicodeString & paramName,
      EnSearchStrategy strategy,
      const icu::UnicodeString & ancKey) {

    NameValuePair * value = getNameValuePairNoFallback(groupName, paramName, ancKey);

    if (EXISTS(value)) {
      return value;
    }

    //check the fallback groups, if any
    vector < icu::UnicodeString> fallbackGroups;
    generateFallbackGroups(groupName, strategy, fallbackGroups);
    size_t i=0;
    while (i< fallbackGroups.size() && (! EXISTS(value))) {
      value = getNameValuePairNoFallback(fallbackGroups[i], paramName, ancKey);
      i++;
    }

    if (EXISTS(value)) {
      return value;
    }

    //if we get here, one of the following holds true:
    // a) the parameter name is invalid
    // b) the parameter is defined, but no value is specified
    //check for a)
    bool isDefined = isParameterDefined(groupName, paramName, ancKey);
    i = 0;
    while (! isDefined && i < fallbackGroups.size()) {
      isDefined = isParameterDefined(fallbackGroups[i], paramName, ancKey);
      i++;
    }

    if (isDefined) { // case b)
      return NULL;
    } else { // a)
      if (hasGroups()) {
        ErrorMessage msg(UIMA_MSG_ID_EXC_CONFIG_PARAM_NOT_DEFINED_IN_GROUP);
        msg.addParam(paramName);
        msg.addParam(groupName);
        UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                           UIMA_ERR_CONFIG_PARAM_NOT_DEFINED_IN_GROUP,
                           msg,
                           ErrorMessage(UIMA_MSG_ID_EXCON_CONFIG_PARAM_SEARCH, paramName),
                           ErrorInfo::recoverable);
      } else {
        UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                           UIMA_ERR_CONFIG_PARAM_NOT_DEFINED,
                           ErrorMessage(UIMA_MSG_ID_EXC_CONFIG_PARAM_NOT_DEFINED, paramName),
                           ErrorMessage(UIMA_MSG_ID_EXCON_CONFIG_PARAM_SEARCH, paramName),
                           ErrorInfo::recoverable);
      }
    }
  }

  NameValuePair * AnalysisEngineMetaData::getNameValuePairNoFallback(const icu::UnicodeString & groupName,
      const icu::UnicodeString & paramName,
      const icu::UnicodeString & ancKey) {
    //sanity check
    if (! hasGroups()
        && (groupName.compare(CONFIG_GROUP_NAME_WHEN_NO_GROUPS) != 0)
       ) {
      // return UIMA_ERR_CONFIG_NO_GROUPS_DEFINED;
      ErrorMessage errmsgContext(UIMA_MSG_ID_EXCON_CONFIG_PARAM_IN_GROUP_SEARCH);
      errmsgContext.addParam(paramName);
      errmsgContext.addParam(groupName);
      UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                         UIMA_ERR_CONFIG_NO_GROUPS_DEFINED,
                         UIMA_MSG_ID_EXC_CONFIG_NO_GROUPS_DEFINED,
                         errmsgContext,
                         ErrorInfo::recoverable);
    }

    //try to find the value for the exact group
    NameValuePair * value = getNameValuePairPtr(groupName, paramName);
    if (EXISTS(value)) {
      //check whether the parameter is defined for that group
      if (isParameterDefined(groupName, paramName, ancKey)) {
        return value;
      } else {
        //return UIMA_ERR_CONFIG_PARAM_NOT_DEFINED_IN_GROUP;
        if (hasGroups()) {
          ErrorMessage errmsgContext(UIMA_MSG_ID_EXCON_CONFIG_PARAM_IN_GROUP_SEARCH);
          errmsgContext.addParam(paramName);
          errmsgContext.addParam(groupName);
          ErrorMessage errmsgExc(UIMA_MSG_ID_EXC_CONFIG_PARAM_NOT_DEFINED_IN_GROUP);
          errmsgExc.addParam(paramName);
          errmsgExc.addParam(groupName);
          UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                             UIMA_ERR_CONFIG_PARAM_NOT_DEFINED_IN_GROUP,
                             errmsgExc,
                             errmsgContext,
                             ErrorInfo::recoverable);
        } else {
          UIMA_EXC_THROW_NEW(ConfigParamLookupException,
                             UIMA_ERR_CONFIG_PARAM_NOT_DEFINED,
                             ErrorMessage(UIMA_MSG_ID_EXC_CONFIG_PARAM_NOT_DEFINED, paramName),
                             ErrorMessage(UIMA_MSG_ID_EXCON_CONFIG_PARAM_SEARCH, paramName),
                             ErrorInfo::recoverable);
        }
        return NULL;
      }
    } else {
      return NULL;
    }
  }

  TyErrorId AnalysisEngineMetaData::setNameValuePair(const icu::UnicodeString & groupName,
      const NameValuePair & nvPair) {

    if (iv_configurationGroups.size() == 0) {
      return UIMA_ERR_CONFIG_PARAM_NOT_DEFINED;
    }
    const icu::UnicodeString & paramName = nvPair.getName();
    TyConfigGroup::const_iterator ite = iv_configurationGroups.find(groupName);
    if (ite == iv_configurationGroups.end()) {
      return UIMA_ERR_CONFIG_INVALID_GROUP_NAME;
    }
    const ConfigurationParameter * pConfigParm = NULL;

    //now check whether the parameter is defined in the group
    //or in the common parameters
    const ConfigurationGroup & confGroup = ite->second;

    if (confGroup.hasConfigurationParameter(paramName)) {
      pConfigParm = confGroup.getConfigurationParameter(paramName);
    } else {
      //check in the common parameters
      ite = iv_configurationGroups.find(CONFIG_GROUP_NAME_COMMON_PARMS);
      if (ite == iv_configurationGroups.end()) { //there are no common parameters
        return UIMA_ERR_CONFIG_INVALID_PARAM_NAME;
      }
      const ConfigurationGroup & commonGroup = ite->second;
      if (commonGroup.hasConfigurationParameter(paramName)) {
        pConfigParm = commonGroup.getConfigurationParameter(paramName);
      } else {
        return UIMA_ERR_CONFIG_INVALID_PARAM_NAME;
      }
    }

    assert(EXISTS(pConfigParm));
    //check if types and multiplicity match
    if (pConfigParm->getType() != nvPair.getType()) {
      return UIMA_ERR_CONFIG_INVALID_TYPE_FOR_PARAM;
    }
    if ((pConfigParm->isMultiValued() && (! nvPair.isMultiValued())
         || ((! pConfigParm->isMultiValued() && nvPair.isMultiValued())))
       ) {
      return UIMA_ERR_CONFIG_INVALID_TYPE_FOR_PARAM;
    }

    NameValuePair * pair = new NameValuePair(nvPair);
    //we can be sure that the configuration parameter is valid
    addNameValuePair(groupName, pair);
    return UIMA_ERR_NONE;
  }

  void AnalysisEngineMetaData::generateFallbackGroups(const icu::UnicodeString & groupName,
      EnSearchStrategy strategy,
      vector < icu::UnicodeString> & fallbackGroups) {
    int i;
    bool cutOffPossible;
    switch (strategy) {
    case NONE:
      //nothing to be done
      break;
    case DEFAULT_FALLBACK:
      fallbackGroups.push_back(getDefaultGroupName());
      break;
    case LANGUAGE_FALLBACK:
      i=groupName.lastIndexOf("-");
      cutOffPossible = (i != -1);
      while (cutOffPossible) {
        icu::UnicodeString fallback;
        groupName.extract(0, i, fallback);
        fallbackGroups.push_back(fallback);
        i=groupName.lastIndexOf("-", 0,i);
        cutOffPossible = (i != -1);
      }
      fallbackGroups.push_back(getDefaultGroupName());
      break;
    default:
      assert(false);
    }
  }

  /**
  * returns TRUE iff paramName is defined and the configuration parameter is visible
  * to the annotator context with key ancKey.
  **/
  bool AnalysisEngineMetaData::isParameterDefined(const icu::UnicodeString & paramName,
      const icu::UnicodeString & ancKey) const {
    return isParameterDefined(CONFIG_GROUP_NAME_WHEN_NO_GROUPS, paramName, ancKey);
  }
  /**
  * returns TRUE iff paramName is either defined for group groupName or in the commonParameter section.
  * Moreover, the configuration parameter must be visible to the annotator context with key ancKey
  **/
  bool AnalysisEngineMetaData::isParameterDefined(const icu::UnicodeString & groupName,
      const icu::UnicodeString & paramName,
      const icu::UnicodeString & ancKey) const {
    //check if it's defined in the group groupName
    TyConfigGroup::const_iterator ite = iv_configurationGroups.find(groupName);
    if (ite != iv_configurationGroups.end()) {
      const ConfigurationGroup & group = ite->second;
      const ConfigurationParameter * pConfigParm = group.getConfigurationParameter(paramName);
      if (EXISTS(pConfigParm)) { //the parameter exists
        return pConfigParm->isDefinedForAnnotatorContext(ancKey);
      }
      /*          if (group.hasConfigurationParameter(paramName)) { */
      /*             return true;                                   */
      /*          }                                                 */
    }
    //either the group does not exist or it doesn't define the parameter
    //we check in the common parameters
    ite = iv_configurationGroups.find(CONFIG_GROUP_NAME_COMMON_PARMS);
    if (ite != iv_configurationGroups.end()) {
      const ConfigurationGroup & group = ite->second;
      const ConfigurationParameter * pConfigParm = group.getConfigurationParameter(paramName);
      if (EXISTS(pConfigParm)) { //the parameter exists
        return pConfigParm->isDefinedForAnnotatorContext(ancKey);
      } else {
        return false;
      }
      //return group.hasConfigurationParameter(paramName);
    } else {
      return false;
    }
  }

  const vector <icu::UnicodeString> AnalysisEngineMetaData::getConfigurationGroupNames() const {
    vector <icu::UnicodeString> groupNames;
    TyConfigGroup::const_iterator ite;
    for (ite = iv_configurationGroups.begin(); ite != iv_configurationGroups.end(); ite++) {
      const icu::UnicodeString & groupName = ite->first;
      if (CONFIG_GROUP_NAME_COMMON_PARMS.compare(groupName) != 0) {
        groupNames.push_back(groupName);
      }
    }
    return groupNames;
  }

  const vector <const ConfigurationParameter *> AnalysisEngineMetaData::getConfigurationParameters(const icu::UnicodeString & groupName) const {
    vector <const ConfigurationParameter *> confParams;
    TyConfigGroup::const_iterator ite = iv_configurationGroups.find(groupName);
    if (ite == iv_configurationGroups.end()) {
      return confParams;
    }

    //collect the parameters from the group
    const ConfigurationGroup & confGroup = ite->second;
    const vector <const ConfigurationParameter *> params = confGroup.getConfigurationParameters();
    size_t i=0;
    for (i=0; i < params.size(); i++) {
      confParams.push_back(params[i]);
    }

    //collect the parameters from the common group, if any
    if (CONFIG_GROUP_NAME_COMMON_PARMS.compare(groupName) != 0) {
      const vector <const ConfigurationParameter *> commonParams = getConfigurationParameters(CONFIG_GROUP_NAME_COMMON_PARMS);
      for (i=0; i < commonParams.size(); i++) {
        confParams.push_back(commonParams[i]);
      }
    }

    return confParams;
  }

  const vector <icu::UnicodeString > AnalysisEngineMetaData::getGroupNamesForParameter(const icu::UnicodeString & paramName) const {
    vector <icu::UnicodeString > groups;
    vector <icu::UnicodeString> allGroups = getConfigurationGroupNames();
    vector <icu::UnicodeString>::const_iterator ite;
    for (ite = allGroups.begin(); ite != allGroups.end(); ite++) {
      if (isParameterDefined(*ite, paramName, "")) {
        groups.push_back(*ite);
      }
    }
    if (isParameterDefined(CONFIG_GROUP_NAME_COMMON_PARMS, paramName, "") && hasDefaultGroup()) {
      groups.push_back(getDefaultGroupName());
    }
    return groups;
  }


  TyErrorId AnalysisEngineMetaData::addTypePriority(TypePriority * prio) {
    if (! isModifiable()) {
      return UIMA_ERR_CONFIG_OBJECT_COMITTED;
    }
    iv_vecpTypePriorities.push_back(prio);
    return UIMA_ERR_NONE;
  }

  void AnalysisEngineDescription::commit() {
    if (EXISTS(iv_pAeMetaData)) {
      iv_pAeMetaData->commit();
    }
    TyMapDelegateSpecs::iterator ite;
    for (ite=iv_pMapDelegateSpecifiers->begin(); ite != iv_pMapDelegateSpecifiers->end(); ite++) {
      AnalysisEngineDescription * del = ite->second;
      del->commit();
    }
    iv_bIsModifiable = false;
  }


  /*-------------------------------------------------------*/
  /*                                                       */
  /*   AnalysisEngineDescription implementation            */
  /*-------------------------------------------------------*/
  AnalysisEngineDescription * AnalysisEngineDescription::getDelegate(const icu::UnicodeString & key) const {
    TyMapDelegateSpecs::iterator ite = iv_pMapDelegateSpecifiers->find(key);
    if (ite == iv_pMapDelegateSpecifiers->end()) {
      return NULL;
    } else {
      return ite->second;
    }
  }

  AnalysisEngineDescription * AnalysisEngineDescription::extractDelegate(const icu::UnicodeString & key) {
    TyMapDelegateSpecs::iterator ite = iv_pMapDelegateSpecifiers->find(key);
    if (ite == iv_pMapDelegateSpecifiers->end()) {
      return NULL;
    } else {
      AnalysisEngineDescription * taeSpec = ite->second;
      iv_pMapDelegateSpecifiers->erase(ite);
      return taeSpec;
    }
  }

  void AnalysisEngineDescription::toXMLBuffer(icu::UnicodeString & s) const {
    s.removeBetween(0, s.length());
    toXMLBufferNoXMLHeader(s);
    s.insert(0, "<?xml version=\"1.0\"?>");
  }

  void AnalysisEngineDescription::validate() {
    try {
      //first, validate the delegate specs
      AnalysisEngineDescription::TyMapDelegateSpecs delegates = getDelegates();
      AnalysisEngineDescription::TyMapDelegateSpecs::iterator ite = delegates.begin();
      while (ite != delegates.end()) {
		ite->second->validate();
        ite++;
      }

      //merge the type systems
      TypeSystemDescription * typeDesc = getAnalysisEngineMetaData()->getTypeSystemDescription();
      for (ite=delegates.begin(); ite != delegates.end(); ite++) {
        TypeSystemDescription * typeDescDel = ite->second->getAnalysisEngineMetaData()->getTypeSystemDescription();
        typeDesc->mergeTypeDescriptions(typeDescDel->getTypeDescriptions());
      }

      getAnalysisEngineMetaData()->validate();
      //tbd: validate the flow constraints
    } catch (ValidationException & rclException) {
      rclException.getErrorInfo().addContext(ErrorMessage(UIMA_MSG_ID_EXCON_VALIDATE_TAE_SPEC_FROM_FILE, getXmlFileLocation()));
      throw rclException;
    }
  }

  void appendCapabilities(Capability::TyVecCapabilityTofs const & v, char const * xmlTag, icu::UnicodeString & s) {
    size_t i;
    for (i=0; i<v.size(); ++i) {
      s.append("<");
      s.append(xmlTag);
      s.append(">");

      s.append(v[i]);

      s.append("</");
      s.append(xmlTag);
      s.append(">");
    }
  }

  void appendSofaName(Capability::TyVecCapabilitySofas const & v, char const * xmlTag, icu::UnicodeString & s) {
    size_t i;
    for (i=0; i<v.size(); ++i) {
      s.append("<");
      s.append(xmlTag);
      s.append(">");

      s.append(v[i]);

      s.append("</");
      s.append(xmlTag);
      s.append(">");
    }
  }

  void appendBool(bool b, icu::UnicodeString & s) {
    if (b) {
      s.append("true");
    } else {
      s.append("false");
    }
  }

  void appendFloat(float f, icu::UnicodeString & s) {
    char c[256];
    sprintf(c, "%f", f);
    s.append(c);
  }

  void appendInt(int i, icu::UnicodeString & s) {
    char c[256];
    sprintf(c, "%d", i);
    s.append(c);
  }


  void AnalysisEngineDescription::appendConfigGroupToXMLBuffer(ConfigurationGroup const & config, icu::UnicodeString & s) const {
    size_t i;
    vector<ConfigurationParameter const *> configParams = config.getConfigurationParameters();
    for (i=0; i<configParams.size(); ++i) {
      ConfigurationParameter const * confParam = configParams[i];
      s.append("<configurationParameter>");
      s.append("<name>");
      s.append(confParam->getName());
      s.append("</name>");
      s.append("<description>");
      s.append(confParam->getDescription());
      s.append("</description>");
      s.append("<type>");
      ConfigurationParameter::EnParameterType paramType = confParam->getType();
      switch (paramType) {
      case ConfigurationParameter::BOOLEAN:
        s.append("Boolean");
        break;
      case ConfigurationParameter::FLOAT:
        s.append("Float");
        break;
      case ConfigurationParameter::INTEGER:
        s.append("Integer");
        break;
      case ConfigurationParameter::STRING:
        s.append("String");
        break;
      default:
        assert(false);
      }
      s.append("</type>");
      s.append("<multiValued>");
      appendBool(confParam->isMultiValued(), s);
      s.append("</multiValued>");
      s.append("<mandatory>");
      appendBool(confParam->isMandatory(), s);
      s.append("</mandatory>");
      s.append("</configurationParameter>");
    }
  }

  void AnalysisEngineDescription::appendConfigGroupSettingsToXMLBuffer(SettingsForGroup const & settings, icu::UnicodeString & s) const {
    size_t i,j;
    vector<NameValuePair const *> nvps = settings.getNameValuePairs();
    for (i=0; i<nvps.size(); ++i) {
      NameValuePair const * nvp = nvps[i];
      s.append("<nameValuePair>");
      s.append("<name>");
      s.append( nvp->getName() );
      s.append("</name>");

      s.append("<value>");

      ConfigurationParameter::EnParameterType paramType = nvp->getType();
      if (nvp->isMultiValued()) {
        s.append("<array>");

        switch (paramType) {
        case ConfigurationParameter::BOOLEAN: {
            vector<bool> const & v = nvp->extractBoolValues();
            for (j=0; j<v.size(); ++j) {
              s.append("<boolean>");
              appendBool(v[j], s);
              s.append("</boolean>");
            }
            break;
          }
        case ConfigurationParameter::FLOAT: {
            vector<float> const & v = nvp->extractFloatValues();
            for (j=0; j<v.size(); ++j) {
              s.append("<float>");
              appendFloat(v[j], s);
              s.append("</float>");
            }
            break;
          }
        case ConfigurationParameter::INTEGER: {
            vector<int> const & v = nvp->extractIntValues();
            for (j=0; j<v.size(); ++j) {
              s.append("<integer>");
              appendInt(v[j], s);
              s.append("</integer>");
            }
            break;
          }
        case ConfigurationParameter::STRING: {
            vector<icu::UnicodeString> const & v = nvp->extractStringValues();
            for (j=0; j<v.size(); ++j) {
              s.append("<string>");
              s.append(v[j]);
              s.append("</string>");
            }
            break;
          }
        default:
          assert(false);
        }

        s.append("</array>");
      } else {
        switch (paramType) {
        case ConfigurationParameter::BOOLEAN: {
            bool v = nvp->extractBoolValue();
            s.append("<boolean>");
            appendBool(v, s);
            s.append("</boolean>");
            break;
          }
        case ConfigurationParameter::FLOAT: {
            float v = nvp->extractFloatValue();
            s.append("<float>");
            appendFloat(v, s);
            s.append("</float>");
            break;
          }
        case ConfigurationParameter::INTEGER: {
            int v = nvp->extractIntValue();
            s.append("<integer>");
            appendInt(v, s);
            s.append("</integer>");
            break;
          }
        case ConfigurationParameter::STRING: {
            icu::UnicodeString const & v = nvp->extractStringValue();
            s.append("<string>");
            s.append(v);
            s.append("</string>");
            break;
          }
        default:
          assert(false);
        }

      }

      s.append("</value>");
      s.append("</nameValuePair>");
    }
  }


  void  AnalysisEngineDescription::appendToXMLBuffer
  (AnalysisEngineMetaData::TyVecpFSIndexDescriptions const & fsDesc,
   icu::UnicodeString & s) {

    size_t i,j;
    s.append("<fsIndexes>");
    AnalysisEngineMetaData::TyVecpFSIndexDescriptions const & ixVec = fsDesc;
    for (i=0; i<ixVec.size(); ++i) {
      FSIndexDescription const * ixDesc = ixVec[i];
      s.append("<fsIndexDescription>");
      s.append("<label>");
      s.append(ixDesc->getLabel());
      s.append("</label>");
      s.append("<typeName>");
      s.append(ixDesc->getTypeName());
      s.append("</typeName>");
      s.append("<kind>");
      FSIndexDescription::EnIndexKind ixKind = ixDesc->getIndexKind();
      switch (ixKind) {
      case FSIndexDescription::BAG:
        s.append("bag");
        break;
      case FSIndexDescription::SET:
        s.append("set");
        break;
      case FSIndexDescription::SORTED:
        s.append("sorted");
        break;
      default:
        assert(false);
      }
      s.append("</kind>");

      FSIndexDescription::TyVecpFSIndexKeys const & keyVec = ixDesc->getFSIndexKeys();
      if (keyVec.size() > 0) {
        s.append("<keys>");
        for (j=0; j<keyVec.size(); ++j) {
          s.append("<fsIndexKey>");
          FSIndexKeyDescription const * ixKeyDesc = keyVec[j];
          if (ixKeyDesc->isTypePriority() ) {
            s.append("<typePriority/>");
          } else {
              s.append("<featureName>");
              s.append(ixKeyDesc->getFeatureName());
              s.append("</featureName>");

              s.append("<comparator>");
              FSIndexKeyDescription::EnComparatorType comp = ixKeyDesc->getComparator();
              switch (comp) {
              case FSIndexKeyDescription::STANDARD:
                s.append("standard");
                break;
              case FSIndexKeyDescription::REVERSE:
                s.append("reverse");
                break;
              default:
                assert(false);
              }
            s.append("</comparator>");
          }
          s.append("</fsIndexKey>");
        }
        s.append("</keys>");
      }

      s.append("</fsIndexDescription>");
    }

    s.append("</fsIndexes>");

  }


  void AnalysisEngineDescription::appendToXMLBuffer
  (AnalysisEngineMetaData::TyVecpTypePriorities const & prioDesc,
   icu::UnicodeString & s) {
    size_t i,j;
    if (prioDesc.size() > 0) {
      s.append("<typePriorities>");
      for (i=0; i<prioDesc.size() ;++i) {
        s.append("<priorityList>");
        TypePriority * prio = prioDesc[i];
        vector <icu::UnicodeString> vecTypeOrder = prio->getTypeOrder();
        for ( j = 0; j < vecTypeOrder.size();  ++j) {

          s.append("<type>");
          s.append(vecTypeOrder[j]);
          s.append("</type>");
        }
        s.append("</priorityList>");
      }
      s.append("</typePriorities>");
    }
  }


  void AnalysisEngineDescription::appendToXMLBuffer
  (AnalysisEngineDescription::TyVecpSofaMappings const & sofaMapDesc,
   icu::UnicodeString & s) {
    size_t i;
    AnalysisEngineDescription::TyVecpSofaMappings const & sofamappingVec = sofaMapDesc;
    if (sofamappingVec.size() >  0) {
      s.append("<sofaMappings>");
      for (i=0; i<sofamappingVec.size(); ++i) {
        s.append("<sofaMapping>");
        s.append("<componentKey>");
        s.append(sofamappingVec[i]->getComponentKey());
        s.append("</componentKey>");

        s.append("<componentSofaName>");
        s.append(sofamappingVec[i]->getComponentSofaName());
        s.append("</componentSofaName>");

        s.append("<aggregateSofaName>");
        s.append(sofamappingVec[i]->getAggregateSofaName());
        s.append("</aggregateSofaName>");

        s.append("</sofaMapping>");
      }
      s.append("</sofaMappings>");
    }
  }


  void AnalysisEngineDescription::appendConfigParamsAndSettingsToXMLBuffer(icu::UnicodeString & s) const  {


    AnalysisEngineMetaData const & md = * getAnalysisEngineMetaData();
    // config params
    if (md.hasGroups()) {
      s.append("<configurationParameters");

      if (md.hasDefaultGroup()) {
        s.append(" defaultGroup=\"");
        s.append( md.iv_defaultGroup );
        s.append("\"");
      }

      s.append(" searchStrategy=\"");
      AnalysisEngineMetaData::EnSearchStrategy searchStrategy = md.getSearchStrategy();
      switch (searchStrategy) {
      case AnalysisEngineMetaData::DEFAULT_FALLBACK:
        s.append("default_fallback");
        break;
      case AnalysisEngineMetaData::LANGUAGE_FALLBACK:
        s.append("language_fallback");
        break;
      case AnalysisEngineMetaData::NONE:
        s.append("none");
        break;
      }
      s.append("\">");

      AnalysisEngineMetaData::TyConfigGroup const & confGroups = md.iv_configurationGroups;
      assert( confGroups.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS) == confGroups.end() );
      AnalysisEngineMetaData::TyConfigGroup::const_iterator cit;
      for ( cit = confGroups.begin(); cit != confGroups.end(); ++cit) {
        icu::UnicodeString const & confGroupName = (*cit).first;
        ConfigurationGroup const & confGroup = (*cit).second;
        bool common = ( confGroupName == md.CONFIG_GROUP_NAME_COMMON_PARMS);
        if (common) {
          s.append("<commonParameters>");
        } else {
          s.append("<configurationGroup names=\"");
          s.append(confGroupName);
          s.append("\">");
        }

        appendConfigGroupToXMLBuffer( confGroup, s);

        if (common) {
          s.append("</commonParameters>");
        } else {
          s.append("</configurationGroup>");
        }
      }
      s.append("</configurationParameters>");

    } else {
      s.append("<configurationParameters>");
      AnalysisEngineMetaData::TyConfigGroup const & confGroups = md.iv_configurationGroups;
      assert( confGroups.find(md.CONFIG_GROUP_NAME_COMMON_PARMS) == confGroups.end() );
      if (confGroups.size() > 0) {
        assert( confGroups.size() == 1);
        AnalysisEngineMetaData::TyConfigGroup::const_iterator cit = confGroups.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS);
        assert( cit != confGroups.end() );
        appendConfigGroupToXMLBuffer( (*cit).second, s);
      }
      s.append("</configurationParameters>");
    }


    s.append("<configurationParameterSettings>");
    // config param settings
    if (md.hasGroups()) {
      AnalysisEngineMetaData::TyConfigSettings const & confSettings = md.iv_configurationSettings;
      AnalysisEngineMetaData::TyConfigSettings::const_iterator cit;
      for (cit = confSettings.begin(); cit != confSettings.end(); ++cit) {
        icu::UnicodeString const & groupName = (*cit).first;
        SettingsForGroup const & settings = (*cit).second;

        s.append("<settingsForGroup name=\"");
        s.append(groupName);
        s.append("\">");
        appendConfigGroupSettingsToXMLBuffer(settings, s);
        s.append("</settingsForGroup>");
      }

    } else {
      AnalysisEngineMetaData::TyConfigSettings const & confSettings = md.iv_configurationSettings;
      if (confSettings.size() > 0) {
        assert( confSettings.size() == 1);
        AnalysisEngineMetaData::TyConfigSettings::const_iterator cit = confSettings.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS);
        assert( cit != confSettings.end() );
        appendConfigGroupSettingsToXMLBuffer( (*cit).second, s);
      }
    }
    s.append("</configurationParameterSettings>");


  }


  void AnalysisEngineDescription::toXMLBufferNoXMLHeader(icu::UnicodeString & s) const {
    size_t i;
    bool isCasConsumer=false;
    if ( getXmlRootTag().compare("casConsumerDescription") == 0) {
      isCasConsumer=true;
    }

    s = "<";
    s.append(getXmlRootTag());
    s.append(" xmlns=\"" UIMA_XML_NAMESPACE "\">");

    // framework
    s.append("<frameworkImplementation>");
    EnFrameworkImplName fwName = getFrameworkImplName();
    switch (fwName) {
    case CPLUSPLUS:
      s.append("org.apache.uima.cpp");
      break;
    case JAVA:
      s.append("org.apache.uima.java");
      break;
    default:
      assert(false);
    };
    s.append("</frameworkImplementation>");


    if (isCasConsumer) {
      s.append("<implementationName>");
      s.append(getAnnotatorImpName());
      s.append("</implementationName>");
    }
    // primitive
    else  {
      // primitive
      s.append("<primitive>");
      appendBool(isPrimitive(), s);
      s.append("</primitive>");

      if (isPrimitive()) {
        // annotator implementation
        s.append("<annotatorImplementationName>");
        s.append(getAnnotatorImpName());
        s.append("</annotatorImplementationName>");
      } else {
        // delegates
        s.append("<delegateAnalysisEngineSpecifiers>");
        TyMapDelegateSpecs const & delegates = getDelegates();
        TyMapDelegateSpecs::const_iterator cit;
        for (cit = delegates.begin(); cit != delegates.end(); ++cit) {
          s.append("<delegateAnalysisEngine key=\"");
          s.append( (*cit).first );
          s.append("\">");
          icu::UnicodeString delBuf;
          (*cit).second->toXMLBufferNoXMLHeader(delBuf);
          s.append(delBuf);
          s.append("</delegateAnalysisEngine>");
        }
        s.append("</delegateAnalysisEngineSpecifiers>");
      }
    }

	toXMLBuffer( *(getAnalysisEngineMetaData()), isCasConsumer, s);

	if (!isCasConsumer) {
      TyVecpSofaMappings const & sofamappingVec = getSofaMappings();
      if (sofamappingVec.size() >  0) {
        s.append("<sofaMappings>");
        for (i=0; i<sofamappingVec.size(); ++i) {
          s.append("<sofaMapping>");
          s.append("<componentKey>");
          s.append(sofamappingVec[i]->getComponentKey());
          s.append("</componentKey>");

          s.append("<componentSofaName>");
          s.append(sofamappingVec[i]->getComponentSofaName());
          s.append("</componentSofaName>");

          s.append("<aggregateSofaName>");
          s.append(sofamappingVec[i]->getAggregateSofaName());
          s.append("</aggregateSofaName>");

          s.append("</sofaMapping>");
        }
        s.append("</sofaMappings>");
      }
    }

    s.append("</");
    s.append(getXmlRootTag());
    s.append(">");


  }

  void AnalysisEngineDescription::toXMLBuffer(AnalysisEngineMetaData const & md,  
													   bool isCasConsumer,
													   icu::UnicodeString & s) const {
    size_t i,j;
    // AE Meta data
	
    if (isCasConsumer) {
      s.append("<processingResourceMetaData>");
    } else s.append("<analysisEngineMetaData xmlns=\"http://uima.apache.org/resourceSpecifier\">");
    

    ///AnalysisEngineMetaData const & md = * getAnalysisEngineMetaData();
    
    //    name
    icu::UnicodeString out;
    s.append("<name>");
    XMLWriterABase::normalize(UnicodeStringRef(md.getName()), out);
    s.append(out);
    s.append("</name>");

    //   description
    s.append("<description>");
    out.setTo("");
    XMLWriterABase::normalize(UnicodeStringRef(md.getDescription()), out);
    s.append( out );
    s.append("</description>");

    //   version
    s.append("<version>");
    s.append( md.getVersion() );
    s.append("</version>");

    //   vendor
    s.append("<vendor>");
    out.setTo("");
     XMLWriterABase::normalize(UnicodeStringRef(md.getVendor()), out);
    s.append( out );
    s.append("</vendor>");


    // config params
    if (md.hasGroups()) {
      s.append("<configurationParameters");

      if (md.hasDefaultGroup()) {
        s.append(" defaultGroup=\"");
        s.append( md.iv_defaultGroup );
        s.append("\"");
      }

      s.append(" searchStrategy=\"");
      AnalysisEngineMetaData::EnSearchStrategy searchStrategy = md.getSearchStrategy();
      switch (searchStrategy) {
      case AnalysisEngineMetaData::DEFAULT_FALLBACK:
        s.append("default_fallback");
        break;
      case AnalysisEngineMetaData::LANGUAGE_FALLBACK:
        s.append("language_fallback");
        break;
      case AnalysisEngineMetaData::NONE:
        s.append("none");
        break;
      }
      s.append("\">");

      AnalysisEngineMetaData::TyConfigGroup const & confGroups = md.iv_configurationGroups;
      assert( confGroups.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS) == confGroups.end() );
      AnalysisEngineMetaData::TyConfigGroup::const_iterator cit;
      for ( cit = confGroups.begin(); cit != confGroups.end(); ++cit) {
        icu::UnicodeString const & confGroupName = (*cit).first;
        ConfigurationGroup const & confGroup = (*cit).second;
        bool common = ( confGroupName == md.CONFIG_GROUP_NAME_COMMON_PARMS);
        if (common) {
          s.append("<commonParameters>");
        } else {
          s.append("<configurationGroup names=\"");
          s.append(confGroupName);
          s.append("\">");
        }

        appendConfigGroupToXMLBuffer( confGroup, s);

        if (common) {
          s.append("</commonParameters>");
        } else {
          s.append("</configurationGroup>");
        }
      }
      s.append("</configurationParameters>");

    } else {
      s.append("<configurationParameters>");
      AnalysisEngineMetaData::TyConfigGroup const & confGroups = md.iv_configurationGroups;
      assert( confGroups.find(md.CONFIG_GROUP_NAME_COMMON_PARMS) == confGroups.end() );
      if (confGroups.size() > 0) {
        assert( confGroups.size() == 1);
        AnalysisEngineMetaData::TyConfigGroup::const_iterator cit = confGroups.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS);
        assert( cit != confGroups.end() );
        appendConfigGroupToXMLBuffer( (*cit).second, s);
      }
      s.append("</configurationParameters>");
    }


    s.append("<configurationParameterSettings>");
    // config param settings
    if (md.hasGroups()) {
      AnalysisEngineMetaData::TyConfigSettings const & confSettings = md.iv_configurationSettings;
      AnalysisEngineMetaData::TyConfigSettings::const_iterator cit;
      for (cit = confSettings.begin(); cit != confSettings.end(); ++cit) {
        icu::UnicodeString const & groupName = (*cit).first;
        SettingsForGroup const & settings = (*cit).second;

        s.append("<settingsForGroup name=\"");
        s.append(groupName);
        s.append("\">");
        appendConfigGroupSettingsToXMLBuffer(settings, s);
        s.append("</settingsForGroup>");
      }

    } else {
      AnalysisEngineMetaData::TyConfigSettings const & confSettings = md.iv_configurationSettings;
      if (confSettings.size() > 0) {
        assert( confSettings.size() == 1);
        AnalysisEngineMetaData::TyConfigSettings::const_iterator cit = confSettings.find(md.CONFIG_GROUP_NAME_WHEN_NO_GROUPS);
        assert( cit != confSettings.end() );
        appendConfigGroupSettingsToXMLBuffer( (*cit).second, s);
      }
    }
    s.append("</configurationParameterSettings>");

    // flow constraints
    if (!isPrimitive()) {
      s.append("<flowConstraints>");
      FlowConstraints const * pFlow = md.getFlowConstraints();
      FlowConstraints * flow = CONST_CAST(FlowConstraints *, pFlow);
      if (flow->getFlowConstraintsType() == FlowConstraints::FIXED) {
        s.append("<fixedFlow>");
      } else if (flow->getFlowConstraintsType() == FlowConstraints::CAPABILITYLANGUAGE) {
        s.append("<capabilityLanguageFlow>");
      }
      vector<icu::UnicodeString> const & v = flow->getNodes();
      for (i=0; i<v.size(); ++i) {
        s.append("<node>");
        s.append(v[i]);
        s.append("</node>");
      }
      if (flow->getFlowConstraintsType() == FlowConstraints::FIXED) {
        s.append("</fixedFlow>");
      }  else if (flow->getFlowConstraintsType() == FlowConstraints::CAPABILITYLANGUAGE) {
        s.append("</capabilityLanguageFlow>");
      }

      s.append("</flowConstraints>");
    }

    //type priorites
    const AnalysisEngineMetaData::TyVecpTypePriorities  & prioDesc =  
                    md.getTypePriorities();
     if (prioDesc.size() > 0) {
      s.append("<typePriorities>");
      for (i=0; i<prioDesc.size() ;++i) {
        s.append("<priorityList>");
        TypePriority * prio = prioDesc[i];
        vector <icu::UnicodeString> vecTypeOrder = prio->getTypeOrder();
        for ( j = 0; j < vecTypeOrder.size();  ++j) {

          s.append("<type>");
          s.append(vecTypeOrder[j]);
          s.append("</type>");
        }
        s.append("</priorityList>");
      }
      s.append("</typePriorities>");
    }

    // type system

      s.append("<typeSystemDescription>");
      TypeSystemDescription const * typeDesc = md.getTypeSystemDescription();
      if (typeDesc != NULL) {
        TypeSystemDescription::TyVecpImportDescriptions const & importVec = typeDesc->getImportDescriptions();
        s.append("<imports>");
        for (i=0; i<importVec.size(); ++i) {
          ImportDescription const * pImport = importVec[i];
          if ( pImport->getName().length() > 0) {
            s.append("<import name=\"");
            s.append(pImport->getName());
            s.append("\"/>");
          } else {
            s.append("<import location=\"");
            s.append(pImport->getLocation());
            s.append("\"/>");
          }
        }
        s.append("</imports><types>");

        TypeSystemDescription::TyVecpTypeDescriptions const & tdVec = typeDesc->getTypeDescriptions();
        for (i=0; i<tdVec.size(); ++i) {
          TypeDescription const * td = tdVec[i];
          s.append("<typeDescription>");
          s.append("<name>");
          s.append(td->getName());
          s.append("</name>");

          s.append("<description>");
          out.setTo("");
          XMLWriterABase::normalize(UnicodeStringRef(td->getDescription()), out);
          s.append(out);
          s.append("</description>");

          s.append("<supertypeName>");
          s.append(td->getSuperTypeName());
          s.append("</supertypeName>");

          TypeDescription::TyVecpFeatureDescriptions const & fdVec = td->getFeatureDescriptions();
          if (fdVec.size() > 0) {
            s.append("<features>");
            for (j=0; j<fdVec.size(); ++j) {
              FeatureDescription const * fs = fdVec[j];
              s.append("<featureDescription>");
              s.append("<name>");
              s.append(fs->getName());
              s.append("</name>");
              s.append("<description>");
              out.setTo("");
              XMLWriterABase::normalize(UnicodeStringRef(fs->getDescription()), out);
              s.append(out);
              s.append("</description>");
              s.append("<rangeTypeName>");
              s.append(fs->getRangeTypeName());
              s.append("</rangeTypeName>");
              if (0 < fs->getElementType().length() ) {
                s.append("<elementType>");
                s.append(fs->getElementType());
                s.append("</elementType>");
              }
              if (fs->isMultipleReferencesAllowed() ) {
                s.append("<multipleReferencesAllowed>");
                s.append("true");
                s.append("</multipleReferencesAllowed>");
              }
              s.append("</featureDescription>");
            }
            s.append("</features>");
          }

          TypeDescription::TyVecpAllowedValues const & allowVec = td->getAllowedValues();
          if (allowVec.size() > 0) {
            s.append("<allowedValues>");
            for (j=0; j<allowVec.size(); ++j) {
              AllowedValue const * value = allowVec[j];
              s.append("<value>");
              s.append("<string>");
              s.append(value->getName());
              s.append("</string>");
              s.append("<description>");
              out.setTo("");
              XMLWriterABase::normalize(UnicodeStringRef(value->getDescription()), out);
              s.append(out);
              s.append("</description>");
              s.append("</value>");
            }
            s.append("</allowedValues>");
          }

          s.append("</typeDescription>");
        }
      }
      s.append("</types></typeSystemDescription>");

    //fsIndexCollection
    s.append("<fsIndexCollection>");
    //fsIndexCollection -- imports
    AnalysisEngineMetaData::TyVecpFSIndexImportDescriptions const & ixImportVec = md.getFSIndexImportDescriptions();
    if (ixImportVec.size() > 0 ) {
      s.append("<imports>");
      for (size_t i=0; i < ixImportVec.size(); i++) {
        ImportDescription const * pImport = ixImportVec[i];
        if ( pImport->getName().length() > 0) {
          s.append("<import name=\"");
          s.append(pImport->getName());
          s.append("\"/>");
        } else {
          s.append("<import location=\"");
          s.append(pImport->getLocation());
          s.append("\"/>");
        }
      }
      s.append("</imports>");
    }

    // fs indexes
    s.append("<fsIndexes>");
    AnalysisEngineMetaData::TyVecpFSIndexDescriptions const & ixVec = md.getFSIndexDescriptions();
    for (i=0; i<ixVec.size(); ++i) {
      FSIndexDescription const * ixDesc = ixVec[i];
      s.append("<fsIndexDescription>");
      s.append("<label>");
      s.append(ixDesc->getLabel());
      s.append("</label>");
      s.append("<typeName>");
      s.append(ixDesc->getTypeName());
      s.append("</typeName>");
      s.append("<kind>");
      FSIndexDescription::EnIndexKind ixKind = ixDesc->getIndexKind();
      switch (ixKind) {
      case FSIndexDescription::BAG:
        s.append("bag");
        break;
      case FSIndexDescription::SET:
        s.append("set");
        break;
      case FSIndexDescription::SORTED:
        s.append("sorted");
        break;
      default:
        assert(false);
      }
      s.append("</kind>");

      FSIndexDescription::TyVecpFSIndexKeys const & keyVec = ixDesc->getFSIndexKeys();
      if (keyVec.size() > 0) {
        s.append("<keys>");
        for (j=0; j<keyVec.size(); ++j) {
          s.append("<fsIndexKey>");
          FSIndexKeyDescription const * ixKeyDesc = keyVec[j];
          if (ixKeyDesc->isTypePriority() ) {
            s.append("<typePriority/>");
          } else {
            s.append("<featureName>");
            s.append(ixKeyDesc->getFeatureName());
            s.append("</featureName>");

            s.append("<comparator>");
            FSIndexKeyDescription::EnComparatorType comp = ixKeyDesc->getComparator();
            switch (comp) {
            case FSIndexKeyDescription::STANDARD:
              s.append("standard");
              break;
            case FSIndexKeyDescription::REVERSE:
              s.append("reverse");
              break;
            default:
              assert(false);
            }
            s.append("</comparator>");
          }
          s.append("</fsIndexKey>");
        }
        s.append("</keys>");
      }

      s.append("</fsIndexDescription>");
    }

    s.append("</fsIndexes>");

    s.append("</fsIndexCollection>");

    // capabilities
    s.append("<capabilities>");
    AnalysisEngineMetaData::TyVecpCapabilities const & capVec = md.getCapabilites();
    for (i=0; i<capVec.size(); ++i) {
      Capability const * cap = capVec[i];
      s.append("<capability>");
      s.append("<inputs>");
      appendCapabilities( cap->getCapabilityTypes(Capability::INPUT), "type", s);
      appendCapabilities( cap->getCapabilityFeatures(Capability::INPUT), "feature", s);
      s.append("</inputs>");
      s.append("<outputs>");
      appendCapabilities( cap->getCapabilityTypes(Capability::OUTPUT), "type", s);
      appendCapabilities( cap->getCapabilityFeatures(Capability::OUTPUT), "feature", s);
      s.append("</outputs>");

      s.append("<inputSofas>");
      appendCapabilities( cap->getCapabilitySofas(Capability::INPUTSOFA), "sofaName", s);
      s.append("</inputSofas>");

      s.append("<outputSofas>");
      appendCapabilities( cap->getCapabilitySofas(Capability::OUTPUTSOFA), "sofaName", s);
      s.append("</outputSofas>");


      s.append("<languagesSupported>");
      Capability::TyVecCapabilityLanguages const & suppLangVec = cap->getSupportedLanguages();
      for (j=0; j<suppLangVec.size(); ++j) {
        s.append("<language>");
        s.append(suppLangVec[j]);
        s.append("</language>");
      }
      s.append("</languagesSupported>");

      s.append("</capability>");
    }

    s.append("</capabilities>");
    
    if (this->getAnalysisEngineMetaData()->getOperationalProperties() != 0) {
      s.append("<operationalProperties>"); 
      s.append ("<modifiesCas>");
      appendBool(this->getAnalysisEngineMetaData()->getOperationalProperties()->getModifiesCas(), s);
      s.append ("</modifiesCas>");
      s.append ("<multipleDeploymentAllowed>");
      appendBool(this->getAnalysisEngineMetaData()->getOperationalProperties()->isMultipleDeploymentAllowed(), s);
      s.append("</multipleDeploymentAllowed>");
      s.append("<outputsNewCASes>");
      appendBool(this->getAnalysisEngineMetaData()->getOperationalProperties()->getOutputsNewCASes(), s);
      s.append("</outputsNewCASes>");
      s.append("</operationalProperties>");
    } else {
      s.append("<operationalProperties>"); 
      s.append ("<modifiesCas>true</modifiesCas>");
      s.append("<multipleDeploymentAllowed>true</multipleDeploymentAllowed>");
      s.append("<outputsNewCASes>false</outputsNewCASes>");
      s.append("</operationalProperties>");
    }
    if (isCasConsumer) {
      s.append("</processingResourceMetaData>");
    } else s.append("</analysisEngineMetaData>");
	
 }

    
} //namespace