/** \file casdefinition.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:

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


-------------------------------------------------------------------------- */


/* ----------------------------------------------------------------------- */
/*       Include dependencies                                              */
/* ----------------------------------------------------------------------- */
#include "uima/pragmas.hpp"

#include "xercesc/util/PlatformUtils.hpp"
#include "xercesc/parsers/XercesDOMParser.hpp"
#include "xercesc/parsers/SAXParser.hpp"
#include "xercesc/dom/DOMException.hpp"
#include "xercesc/dom/DOMNamedNodeMap.hpp"
#include "xercesc/dom/DOMDocument.hpp"
#include "xercesc/dom/DOMElement.hpp"
#include "xercesc/dom/DOMNodeList.hpp"

#include "xercesc/sax/ErrorHandler.hpp"
#include "xercesc/sax/AttributeList.hpp"
#include "xercesc/sax/SAXParseException.hpp"
#include "xercesc/framework/LocalFileInputSource.hpp"
#include "xercesc/framework/MemBufInputSource.hpp"

#include "uima/macros.h"
#include "uima/engine.hpp"   // for exception declarations
#include "uima/msg.h"
#include "uima/casdefinition.hpp"
#include "uima/lowlevel_typesystem.hpp"
#include "uima/lowlevel_indexdefinition.hpp"
#include "uima/annotator_context.hpp"
#include "uima/resmgr.hpp"
#include "uima/taespecifierbuilder.hpp"
#include "uima/xmlerror_handler.hpp"

using namespace std;
/* ----------------------------------------------------------------------- */
/*       Constants                                                         */
/* ----------------------------------------------------------------------- */
namespace uima {
  lowlevel::TypeSystem::StTypeInfo gs_arCASTypes[] = {
        { CAS::TYPE_NAME_SOFA,                   CAS::TYPE_NAME_TOP,              "Predefined sofa type"},
        { CAS::TYPE_NAME_ANNOTATION_BASE,        CAS::TYPE_NAME_TOP,             "Predefined annotation type"},
        { CAS::TYPE_NAME_ANNOTATION,             CAS::TYPE_NAME_ANNOTATION_BASE, "Predefined annotation type"},
        { CAS::TYPE_NAME_DOCUMENT_ANNOTATION,    CAS::TYPE_NAME_ANNOTATION,       "Predefined document annotation type"},
      };

  lowlevel::TypeSystem::StFeatureInfo gs_arCASFeatures[] = {
        { CAS::FEATURE_BASE_NAME_SOFANUM,   CAS::TYPE_NAME_SOFA,        CAS::TYPE_NAME_INTEGER, false, "Predefined feature for sofa"},
        { CAS::FEATURE_BASE_NAME_SOFAID,    CAS::TYPE_NAME_SOFA,        CAS::TYPE_NAME_STRING,  false, "Predefined feature for sofa"},
        { CAS::FEATURE_BASE_NAME_SOFAMIME,  CAS::TYPE_NAME_SOFA,        CAS::TYPE_NAME_STRING,  false, "Predefined feature for sofa"},

        { CAS::FEATURE_BASE_NAME_SOFAARRAY,  CAS::TYPE_NAME_LOCALSOFA,   CAS::TYPE_NAME_TOP,     false, "Predefined feature for sofa"},
        { CAS::FEATURE_BASE_NAME_SOFASTRING, CAS::TYPE_NAME_LOCALSOFA,   CAS::TYPE_NAME_STRING,  false, "Predefined feature for sofa"},
        { CAS::FEATURE_BASE_NAME_SOFAURI,    CAS::TYPE_NAME_REMOTESOFA,  CAS::TYPE_NAME_STRING,  false, "Predefined feature for sofa"},

        { CAS::FEATURE_BASE_NAME_SOFA,  CAS::TYPE_NAME_ANNOTATION, CAS::TYPE_NAME_SOFA,    false, "Predefined sofaReference feature for annotations"},
        { CAS::FEATURE_BASE_NAME_BEGIN, CAS::TYPE_NAME_ANNOTATION, CAS::TYPE_NAME_INTEGER, false, "Predefined beginPosition feature for annotations"},
        { CAS::FEATURE_BASE_NAME_END,   CAS::TYPE_NAME_ANNOTATION, CAS::TYPE_NAME_INTEGER, false, "Predefined endPosition feature for annotations"},

        { CAS::FEATURE_BASE_NAME_LANGUAGE, CAS::TYPE_NAME_DOCUMENT_ANNOTATION, CAS::TYPE_NAME_STRING, false, "Predefined language feature for document annotations"},
      };
}

/* ----------------------------------------------------------------------- */
/*       Forward declarations                                              */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Types / Classes                                                   */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Implementation                                                    */
/* ----------------------------------------------------------------------- */


namespace uima {

  namespace internal {

    uima::lowlevel::TyFSType mergeType(uima::lowlevel::TypeSystem & rTypeSystem,
                                       icu::UnicodeString const & crTypeToBeCreated,
                                       TypeSystemDescription const & crTSDesc,
                                       icu::UnicodeString const & crCreatorID) {
      uima::lowlevel::TyFSType typeToBeCreated = rTypeSystem.getTypeByName(crTypeToBeCreated);
      if (crTSDesc.hasTypeDescription(crTypeToBeCreated)) {
        TypeDescription const * cpTypeDesc = crTSDesc.getTypeDescription(crTypeToBeCreated);
        icu::UnicodeString const & crSuperTypeName = cpTypeDesc->getSuperTypeName();

        // first merge the parent
        uima::lowlevel::TyFSType parent = mergeType(rTypeSystem, crSuperTypeName, crTSDesc, crCreatorID);

        // if string sub type
        if (parent == uima::internal::gs_tyStringType) {
          TypeDescription::TyVecpAllowedValues const & crAllowedValues = cpTypeDesc->getAllowedValues();
          vector<icu::UnicodeString> allowedStringValues;
          TypeDescription::TyVecpAllowedValues::const_iterator cit;
          for (cit = crAllowedValues.begin(); cit != crAllowedValues.end(); ++cit) {
            AllowedValue const * cpAllowedVal = (*cit);
            allowedStringValues.push_back( cpAllowedVal->getName() );
          }

          if (typeToBeCreated == uima::lowlevel::TypeSystem::INVALID_TYPE) {
            // create new string subtype
            return rTypeSystem.createStringSubtype(crTypeToBeCreated, allowedStringValues, crCreatorID);
          } else {
            // check string subtype
            vector<icu::UnicodeString> const & crStringValues = rTypeSystem.getStringsForStringSubtype(typeToBeCreated);
            bool bAreStringSetsEqual = false;
            if (crStringValues.size() == crAllowedValues.size()) {
              size_t i,j;
              size_t uiStringNum = crStringValues.size();
              bAreStringSetsEqual = true;
              for (i=0; i<uiStringNum; ++i) {
                icu::UnicodeString const & crString = crStringValues[i];
                // check that string occurs in the allowed values
                bool bContainsString = false;
                for (j=0; j<uiStringNum; ++j) {
                  if (crString != allowedStringValues[j]) {
                    bContainsString = true;
                    break;
                  }
                }
                if (! bContainsString) {
                  bAreStringSetsEqual = false;
                  break;
                }
              }
            }
            if (! bAreStringSetsEqual) {
              // throw exception
              // allowed values are different
              UIMA_EXC_THROW_NEW(AllowedStringValuesIncompatibleException,
                                 UIMA_ERR_ALLOWED_STRING_VALUES_INCOMPATIBLE,
                                 ErrorMessage(UIMA_MSG_ID_EXC_ALLOWED_STRING_VALUES_INCOMPATIBLE, crTypeToBeCreated),
                                 ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPESYSTEM_FROM_CONFIG),
                                 ErrorInfo::recoverable);
              return 0;
            }
          }
        } else {
          assert(parent != uima::lowlevel::TypeSystem::INVALID_TYPE);
          if (typeToBeCreated == uima::lowlevel::TypeSystem::INVALID_TYPE) {
            return rTypeSystem.createType(parent, crTypeToBeCreated, crCreatorID);
          } else {
            if (parent != rTypeSystem.getParentType(typeToBeCreated)) {
              UIMA_EXC_THROW_NEW(IncompatibleParentTypesException,
                                 UIMA_ERR_INCOMPATIBLE_PARENT_TYPES,
                                 ErrorMessage(UIMA_MSG_ID_EXC_WRONG_PARENT_TYPE, crTypeToBeCreated),
                                 ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPESYSTEM_FROM_CONFIG),
                                 ErrorInfo::recoverable);
              return 0;
            }
          }
        }
        return typeToBeCreated;
      }


      if (typeToBeCreated == uima::lowlevel::TypeSystem::INVALID_TYPE) {
        // unknown type in XML file

        UIMA_EXC_THROW_NEW(UnknownTypeException,
                           UIMA_ERR_UNKNOWN_TYPE,
                           ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_TYPE_NAME, crTypeToBeCreated),
                           ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPESYSTEM_FROM_CONFIG),
                           ErrorInfo::recoverable);

      }
      return typeToBeCreated;
    }


    void CASDefinition::mergeTypeSystem(AnalysisEngineDescription const & crTAESpecifier) {
      icu::UnicodeString const & crCreatorID = crTAESpecifier.getAnalysisEngineMetaData()->getName();

      TypeSystemDescription const * crTSDesc = crTAESpecifier.getAnalysisEngineMetaData()->getTypeSystemDescription();
      mergeTypeSystem(*crTSDesc,crCreatorID);

    }


    void CASDefinition::addTypePriorities(AnalysisEngineDescription const & crTAESpecifier) {
      uima::AnalysisEngineMetaData::TyVecpTypePriorities const & crTypePriorities = crTAESpecifier.getAnalysisEngineMetaData()->getTypePriorities();
      addTypePriorities(crTypePriorities);
    }

    void CASDefinition::createIndexesFromANC(AnnotatorContext const & crANC) {
      AnalysisEngineMetaData::TyVecpFSIndexDescriptions const & crIndexDescVec = crANC.getFSIndexDescriptions();
      createIndexesFromSpecifier(crIndexDescVec);
    }

    CASDefinition * CASDefinition::createCASDefinition(AnnotatorContext const & anc) {
      CASDefinition * result = new CASDefinition(& anc);
      assert( EXISTS(result) );
      result->init();
      result->commit();
      return result;
    }

    void CASDefinition::init() {
      createTypes();
    }

    void CASDefinition::commitTypeSystem() {
      iv_typeSystem->commit();
      createIndexes();
    }

    void CASDefinition::commitIndexDefinition() {
      iv_indexDefinition->commit();
    }

    void CASDefinition::commit() {
      commitTypeSystem();
      commitIndexDefinition();
    }

    void CASDefinition::createTypes() {
      createPredefinedCASTypes();
      if ( iv_annotatorContext != NULL ) {
        mergeTypeSystem(iv_annotatorContext->getTaeSpecifier());
        addTypePriorities(iv_annotatorContext->getTaeSpecifier());
      }
    }
    void CASDefinition::createIndexes() {
      createPredefinedCASIndexes();
      if ( iv_annotatorContext != NULL ) {
        createIndexesFromANC(*iv_annotatorContext);
      }
    }

    void CASDefinition::createPredefinedCASTypes() {
      // the CAS predefined types are created in lowlevel::TypeSystem CTOR
      // add CAS types here
      assert( EXISTS(iv_typeSystem) );
      size_t uiType;
      for (uiType =  0; uiType < NUMBEROF(gs_arCASTypes); ++uiType) {
        lowlevel::TyFSType tyNewType = iv_typeSystem->createType( gs_arCASTypes[uiType], CAS::ustrCREATOR_ID_CAS );
        assert( iv_typeSystem->isValidType(tyNewType) );
      }

      size_t uiFeature;
      for (uiFeature = 0; uiFeature < NUMBEROF(gs_arCASFeatures); ++uiFeature) {
        lowlevel::TyFSFeature tyNewFeature = iv_typeSystem->createFeature( gs_arCASFeatures[uiFeature], CAS::ustrCREATOR_ID_CAS );
        assert( iv_typeSystem->isValidFeature(tyNewFeature) );
      }

    }


    void CASDefinition::createPredefinedCASIndexes() {
      assert( EXISTS(iv_typeSystem) );
      assert( EXISTS(iv_indexDefinition) );

      vector<lowlevel::TyFSFeature> vecKeyFeats;
      vector<uima::lowlevel::IndexComparator::EnKeyFeatureComp> vecComparators;

      // create sofa index
      UIMA_TPRINT("creating sofa index");
      vecKeyFeats.clear();
      vecComparators.clear();
      vecKeyFeats.push_back( uima::internal::gs_tySofaNumFeature );
      vecComparators.push_back( uima::lowlevel::IndexComparator::STANDARD_COMPARE );

      assert( iv_typeSystem->isValidType( iv_typeSystem->getTypeByName(CAS::TYPE_NAME_SOFA) ) );
      iv_indexDefinition->defineIndex( uima::lowlevel::IndexDefinition::enSet,
                                       iv_typeSystem->getTypeByName(CAS::TYPE_NAME_SOFA),
                                       vecKeyFeats,
                                       vecComparators,
                                       CAS::INDEXID_SOFA);

      // create annotation index
      UIMA_TPRINT("creating default annotation index");
      vecKeyFeats.clear();
      vecComparators.clear();

      assert( areTypeShortcutsCorrect(*iv_typeSystem) );

      vecKeyFeats.push_back( uima::internal::gs_tyBeginPosFeature );
      vecComparators.push_back( uima::lowlevel::IndexComparator::STANDARD_COMPARE );
      vecKeyFeats.push_back( uima::internal::gs_tyEndPosFeature );
      vecComparators.push_back( uima::lowlevel::IndexComparator::REVERSE_STANDARD_COMPARE );
      vecKeyFeats.push_back( uima::lowlevel::TypeSystem::INVALID_FEATURE ); // means that type priority should be respected
      vecComparators.push_back( uima::lowlevel::IndexComparator::STANDARD_COMPARE );

      assert( iv_typeSystem->isValidType( iv_typeSystem->getTypeByName(CAS::TYPE_NAME_ANNOTATION) ) );
      iv_indexDefinition->defineIndex( uima::lowlevel::IndexDefinition::enOrdered,
                                       iv_typeSystem->getTypeByName(CAS::TYPE_NAME_ANNOTATION),
                                       vecKeyFeats,
                                       vecComparators,
                                       CAS::INDEXID_ANNOTATION);

    }

    CASDefinition::CASDefinition(AnnotatorContext const * anc)
        : iv_typeSystem(NULL),
        iv_indexDefinition(NULL),
        iv_annotatorContext(anc) {
      iv_typeSystem = new uima::lowlevel::TypeSystem();
      bOwnsTypeSystem = true;
      assert( EXISTS(iv_typeSystem) );
      iv_indexDefinition = new uima::lowlevel::IndexDefinition(*iv_typeSystem);
      assert( EXISTS(iv_indexDefinition) );

    }


    CASDefinition::~CASDefinition() {

      if (iv_typeSystem != NULL && bOwnsTypeSystem) {
        delete iv_typeSystem;
      }
      if (iv_indexDefinition != NULL) {
        delete iv_indexDefinition;
      }
    }


    uima::lowlevel::TypeSystem & CASDefinition::getTypeSystem() {
      assert( EXISTS(iv_typeSystem) );
      return *iv_typeSystem;
    }

    uima::lowlevel::TypeSystem const & CASDefinition::getTypeSystem() const {
      assert( EXISTS(iv_typeSystem) );
      return *iv_typeSystem;
    }

    uima::lowlevel::IndexDefinition & CASDefinition::getIndexDefinition() {
      assert(EXISTS(iv_indexDefinition));
      return *iv_indexDefinition;
    }

    uima::lowlevel::IndexDefinition const & CASDefinition::getIndexDefinition() const {
      assert(EXISTS(iv_indexDefinition));
      return *iv_indexDefinition;
    }

    void CASDefinition::mergeTypeSystem(TypeSystemDescription const & crTSDesc,
                                        icu::UnicodeString const & crCreatorID) {
      //icu::UnicodeString const & crCreatorID = crAEMDSpecifier.getName();

      uima::lowlevel::TypeSystem & rTypeSystem = * iv_typeSystem;

      TypeSystemDescription::TyVecpTypeDescriptions const & crTypeDescVector = crTSDesc.getTypeDescriptions();
      TypeSystemDescription::TyVecpTypeDescriptions::const_iterator cit;

      // create types
      for (cit = crTypeDescVector.begin(); cit != crTypeDescVector.end(); ++cit) {
        TypeDescription const * pTypeDesc = *cit;
        icu::UnicodeString const & crTypeName = pTypeDesc->getName();
        mergeType( rTypeSystem, crTypeName, crTSDesc, crCreatorID );
      }

      // create features
      for (cit = crTypeDescVector.begin(); cit != crTypeDescVector.end(); ++cit) {
        TypeDescription const * pTypeDesc = *cit;
        uima::lowlevel::TyFSType introType = rTypeSystem.getTypeByName( pTypeDesc->getName() );
        // type must have been merged before
        assert( rTypeSystem.isValidType(introType) );

        TypeDescription::TyVecpFeatureDescriptions const & crFeatDescs = pTypeDesc->getFeatureDescriptions();
        TypeDescription::TyVecpFeatureDescriptions::const_iterator citFeats;
        // for all features introduced on introType
        for (citFeats = crFeatDescs.begin(); citFeats != crFeatDescs.end(); ++ citFeats) {
          FeatureDescription const * pFeatDesc = *citFeats;
          icu::UnicodeString const & crFeatureName = pFeatDesc->getName();
          icu::UnicodeString const & crRangeTypeName = pFeatDesc->getRangeTypeName();
		  bool multiRefs = pFeatDesc->isMultipleReferencesAllowed();
          uima::lowlevel::TyFSType rangeType = rTypeSystem.getTypeByName(crRangeTypeName);
          if ( !rTypeSystem.isValidType(rangeType) ) {
            // throw exception
            // unknown range type
            ErrorMessage errMessage(UIMA_MSG_ID_EXC_INVALID_RANGE_TYPE, crFeatureName);
            errMessage.addParam( crRangeTypeName );
            UIMA_EXC_THROW_NEW(UnknownRangeTypeException,
                               UIMA_ERR_UNKNOWN_RANGE_TYPE,
                               errMessage,
                               ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPESYSTEM_FROM_CONFIG),
                               ErrorInfo::recoverable);
          }

          uima::lowlevel::TyFSFeature feat = rTypeSystem.getFeatureByBaseName( introType, crFeatureName );
          // if feature exists
          if ( rTypeSystem.isValidFeature(feat) ) {
            // check that range type is correct
            uima::lowlevel::TyFSType actualRangeType = rTypeSystem.getRangeType(feat);
            if (actualRangeType != rangeType) {
              // throw exception
              // incorrect range type of existing feature
              ErrorMessage errMessage(UIMA_MSG_ID_EXC_INCOMPATIBLE_RANGE_TYPE, crFeatureName);
              errMessage.addParam( crRangeTypeName );
              UIMA_EXC_THROW_NEW(IncompatibleRangeTypeException,
                                 UIMA_ERR_INCOMPATIBLE_RANGE_TYPE,
                                 errMessage,
                                 ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPESYSTEM_FROM_CONFIG),
                                 ErrorInfo::recoverable);
            }
          } else {
            // create feature
            rTypeSystem.createFeature(introType, rangeType, multiRefs, crFeatureName, crCreatorID);
          }
        }
      }
    }


    void CASDefinition::addTypePriorities(uima::AnalysisEngineMetaData::TyVecpTypePriorities const & crTypePriorities) {
      uima::lowlevel::TypeSystem & rTypeSystem = *iv_typeSystem;

      //uima::AnalysisEngineMetaData::TyVecpTypePriorities const & crTypePriorities = crAEMDSpecifier.getTypePriorities();
      uima::AnalysisEngineMetaData::TyVecpTypePriorities::const_iterator cit;
      // for all type priority chains
      for (cit = crTypePriorities.begin(); cit != crTypePriorities.end(); ++cit) {
        TypePriority const * cpTypePriority = *cit;
        assert( EXISTS(cpTypePriority) );
        vector<icu::UnicodeString> const & crTypeChain = cpTypePriority->getTypeOrder();
        size_t i;
        // walk along the chain
        for (i=0; i<crTypeChain.size()-1; ++i) {
          uima::lowlevel::TyFSType t1 = rTypeSystem.getTypeByName(crTypeChain[i]);
          if (t1 == uima::lowlevel::TypeSystem::INVALID_TYPE) {
            UIMA_EXC_THROW_NEW(UnknownTypeException,
                               UIMA_ERR_UNKNOWN_TYPE,
                               ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_TYPE_NAME, crTypeChain[i]),
                               ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPEPRIORITIES_FROM_CONFIG),
                               ErrorInfo::recoverable);
          }
          uima::lowlevel::TyFSType t2 = rTypeSystem.getTypeByName(crTypeChain[i+1]);
          if (t2 == uima::lowlevel::TypeSystem::INVALID_TYPE) {
            UIMA_EXC_THROW_NEW(UnknownTypeException,
                               UIMA_ERR_UNKNOWN_TYPE,
                               ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_TYPE_NAME, crTypeChain[i+1]),
                               ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPEPRIORITIES_FROM_CONFIG),
                               ErrorInfo::recoverable);
          }
          // t1 should have priority over t2
          bool bTPCouldBeAdded = rTypeSystem.addTypePriority(t1, t2);
          if (!bTPCouldBeAdded) {
            ErrorMessage errMsg(UIMA_MSG_ID_EXC_TYPE_PRIORITY_CONFLICT);
            errMsg.addParam( crTypeChain[i] );
            errMsg.addParam( crTypeChain[i+1] );

            UIMA_EXC_THROW_NEW(TypePriorityConflictException,
                               UIMA_ERR_TYPE_PRIORITY_CONFLICT,
                               errMsg,
                               ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_TYPEPRIORITIES_FROM_CONFIG),
                               ErrorInfo::recoverable);
          }
        }
      }

    }


    void CASDefinition::createIndexesFromSpecifier(AnalysisEngineMetaData::TyVecpFSIndexDescriptions const & crIndexDescVec) {
      uima::lowlevel::TypeSystem const & crTypeSystem = *iv_typeSystem;

      vector<uima::lowlevel::TyFSFeature> keyFeatures;
      vector<uima::lowlevel::IndexComparator::EnKeyFeatureComp> comparators;

      AnalysisEngineMetaData::TyVecpFSIndexDescriptions::const_iterator citIndex;
      // for all index descriptions
      for (citIndex = crIndexDescVec.begin(); citIndex != crIndexDescVec.end(); ++citIndex) {
        FSIndexDescription const * cpIndexDesc = *citIndex;

        // determine index kind
        FSIndexDescription::EnIndexKind indexDescKind = cpIndexDesc->getIndexKind();
        uima::lowlevel::IndexDefinition::EnIndexKind kind = uima::lowlevel::IndexDefinition::enOrdered;
        switch (indexDescKind) {
        case FSIndexDescription::SORTED:
          kind = uima::lowlevel::IndexDefinition::enOrdered;
          break;
        case FSIndexDescription::SET:
          kind = uima::lowlevel::IndexDefinition::enSet;
          break;
        case FSIndexDescription::BAG:
          kind = uima::lowlevel::IndexDefinition::enFIFO;
          break;
        default:
          assert(false);
        }

        icu::UnicodeString const & crTypeName = cpIndexDesc->getTypeName();
        // type is the type the index is defined on
        uima::lowlevel::TyFSType type = crTypeSystem.getTypeByName(crTypeName);
        if (! crTypeSystem.isValidType(type) ) {
          UIMA_EXC_THROW_NEW(UnknownTypeException,
                             UIMA_ERR_UNKNOWN_TYPE,
                             ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_TYPE_NAME, crTypeName),
                             ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_INDEXES_FROM_CONFIG),
                             ErrorInfo::recoverable);
        }

        icu::UnicodeString const & crIndexLabel = cpIndexDesc->getLabel();

        // determine key features and comparison scheme for each feature
        keyFeatures.clear();
        comparators.clear();

        uima::FSIndexDescription::TyVecpFSIndexKeys const & crIndexKeys = cpIndexDesc->getFSIndexKeys();
        uima::FSIndexDescription::TyVecpFSIndexKeys::const_iterator citKeys;
        // for each key feature
        for (citKeys = crIndexKeys.begin(); citKeys != crIndexKeys.end(); ++citKeys) {
          FSIndexKeyDescription const * cpIndexKeyDesc = *citKeys;

          uima::lowlevel::TyFSFeature feat;
          bool bIsTypePriority = cpIndexKeyDesc->isTypePriority();
          if ( ! bIsTypePriority) {
            icu::UnicodeString const & crFeatureName = cpIndexKeyDesc->getFeatureName();

            feat = crTypeSystem.getFeatureByBaseName( type, crFeatureName);
            if (! crTypeSystem.isValidFeature(feat) ) {
              UIMA_EXC_THROW_NEW(UnknownFeatureException,
                                 UIMA_ERR_UNKNOWN_FEATURE,
                                 ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_FEATURE_NAME, crFeatureName),
                                 ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_INDEXES_FROM_CONFIG),
                                 ErrorInfo::recoverable);

            }
            assert( crTypeSystem.isValidFeature(feat) );
          } else {
            // use INVALID_FEATURE as a marker for type priority
            feat = uima::lowlevel::TypeSystem::INVALID_FEATURE;
          }

          keyFeatures.push_back(feat);


          FSIndexKeyDescription::EnComparatorType enComp = FSIndexKeyDescription::STANDARD;
          // this if statement is not necessary when type priorities can have different kind of comparators!!
          if (! bIsTypePriority) {
            enComp = cpIndexKeyDesc->getComparator();
          }
          switch (enComp) {
          case FSIndexKeyDescription::STANDARD:
            comparators.push_back( uima::lowlevel::IndexComparator::STANDARD_COMPARE );
            break;
          case FSIndexKeyDescription::REVERSE:
            comparators.push_back( uima::lowlevel::IndexComparator::REVERSE_STANDARD_COMPARE );
            break;
          default:
            assert(false);
          }

        }

        iv_indexDefinition->defineIndex( kind,
                                         type,
                                         keyFeatures,
                                         comparators,
                                         crIndexLabel );
      }


    }

    //creates typesystem and index definition
    CASDefinition * CASDefinition::createCASDefinition(AnalysisEngineDescription const & taeSpecifier) {
      //resolve imports
      if (taeSpecifier.isModifiable() ) {
        AnalysisEngineDescription & taespec = CONST_CAST(AnalysisEngineDescription &, taeSpecifier);
        taespec.commit();
      }

      CASDefinition * result = new CASDefinition(taeSpecifier);
      assert( EXISTS(result) );
      //result->init();
      result->createPredefinedCASTypes();
      result->mergeTypeSystem(*taeSpecifier.getAnalysisEngineMetaData()->getTypeSystemDescription(),
                              taeSpecifier.getAnalysisEngineMetaData()->getName());
      result->addTypePriorities(taeSpecifier.getAnalysisEngineMetaData()->getTypePriorities());

      //result->commit();
      result->commitTypeSystemOnly();
      result->createPredefinedCASIndexes();
      result->createIndexesFromSpecifier(taeSpecifier.getAnalysisEngineMetaData()->getFSIndexDescriptions());
      result->commitIndexDefinition();

      return result;
    }

    //creates typesystem and index definition from
    CASDefinition * CASDefinition::createCASDefinition(AnalysisEngineMetaData const & aeDesc) {
      if (aeDesc.isModifiable()) {
        AnalysisEngineMetaData & ae = CONST_CAST(AnalysisEngineMetaData &, aeDesc);
        ae.commit();
      }

      CASDefinition * result = new CASDefinition();
      assert( EXISTS(result) );

      result->createPredefinedCASTypes();
      //result->mergeTypeSystem(casSpecifier);
      result->mergeTypeSystem(*aeDesc.getTypeSystemDescription(),
                              aeDesc.getName());

      result->addTypePriorities(aeDesc.getTypePriorities());
      result->commitTypeSystemOnly();

      result->createPredefinedCASIndexes();
      result->createIndexesFromSpecifier(aeDesc.getFSIndexDescriptions());
      result->commitIndexDefinition();

      return result;
    }

    //creates a CASDefinition with input TypeSystem object and creates index definition
    //based on the specifications
    CASDefinition * CASDefinition::createCASDefinition(uima::TypeSystem & typeSystem,
        AnalysisEngineMetaData const & aeDesc) {

      CASDefinition * result = new CASDefinition(typeSystem);
      assert( EXISTS(result) );

      result->createPredefinedCASIndexes();
      result->createIndexesFromSpecifier(aeDesc.getFSIndexDescriptions());
      result->commitIndexDefinition();

      return result;

    }

    CASDefinition * CASDefinition::createCASDefinition(TypeSystem   & typeSystem,
        AnalysisEngineMetaData::TyVecpFSIndexDescriptions  const & fsDesc,
        AnalysisEngineMetaData::TyVecpTypePriorities   const & prioDesc) {

      CASDefinition * result = new CASDefinition(typeSystem);
      assert( EXISTS(result) );

      result->createPredefinedCASIndexes();
      result->createIndexesFromSpecifier(fsDesc);
      //TODO: addTypePriorities
      result->commitIndexDefinition();

      return result;

    }

    CASDefinition * CASDefinition::createCASDefinition(TypeSystem   & typeSystem,
        AnalysisEngineMetaData::TyVecpFSIndexDescriptions  const & fsDesc) {

      CASDefinition * result = new CASDefinition(typeSystem);
      assert( EXISTS(result) );

      result->createPredefinedCASIndexes();
      result->createIndexesFromSpecifier(fsDesc);

      result->commitIndexDefinition();

      return result;

    }


    //creates a CASDefition based on input TypeSystem and creates the default/builtin index definition
    CASDefinition * CASDefinition::createCASDefinition(uima::TypeSystem & typeSystem) {
      CASDefinition * result = new CASDefinition(typeSystem);
      assert( EXISTS(result) );
      result->createPredefinedCASIndexes();
      result->commitIndexDefinition();
      return result;
    }


    uima::lowlevel::TypeSystem * CASDefinition::createTypeSystem(AnalysisEngineMetaData const & casSpecifier) {

      uima::lowlevel::TypeSystem * pTypeSystem = new uima::lowlevel::TypeSystem();
      assert( EXISTS(pTypeSystem) );
      CASDefinition * result = new CASDefinition(*pTypeSystem);
      assert( EXISTS(result) );
      result->createPredefinedCASTypes();
      result->mergeTypeSystem(*casSpecifier.getTypeSystemDescription(),
                              casSpecifier.getName());

      result->addTypePriorities(casSpecifier.getTypePriorities());
      pTypeSystem->commit();
      delete result;
      return pTypeSystem;
    }

    uima::lowlevel::TypeSystem * CASDefinition::createTypeSystem(TypeSystemDescription const & crTSDesc,
        icu::UnicodeString const & tsName) {
      //resolve imports
      if (crTSDesc.isModifiable() ) {
        TypeSystemDescription & tsDesc = CONST_CAST(TypeSystemDescription &, crTSDesc);
        tsDesc.commit();
      }

      uima::lowlevel::TypeSystem * pTypeSystem = new uima::lowlevel::TypeSystem();
      assert( EXISTS(pTypeSystem) );
      CASDefinition * result = new CASDefinition(*pTypeSystem);
      assert( EXISTS(result) );
      result->createPredefinedCASTypes();
      result->mergeTypeSystem(crTSDesc, tsName);
      //result->addTypePriorities(casSpecifier);
      pTypeSystem->commit();
      delete result;
      return pTypeSystem;
    }


    uima::lowlevel::TypeSystem * CASDefinition::createTypeSystem(TypeSystemDescription const & crTSDesc,
        AnalysisEngineMetaData::TyVecpTypePriorities const & typePriorities,
        icu::UnicodeString const & tsName) {
      //resolve imports
      if (crTSDesc.isModifiable() ) {
        TypeSystemDescription & tsDesc = CONST_CAST(TypeSystemDescription &, crTSDesc);
        tsDesc.commit();
      }


      uima::lowlevel::TypeSystem * pTypeSystem = new uima::lowlevel::TypeSystem();
      assert( EXISTS(pTypeSystem) );
      CASDefinition * result = new CASDefinition(*pTypeSystem);
      assert( EXISTS(result) );
      result->createPredefinedCASTypes();
      result->mergeTypeSystem(crTSDesc, tsName);
      result->addTypePriorities(typePriorities);
      pTypeSystem->commit();
      delete result;
      return pTypeSystem;
    }


    void CASDefinition::commitTypeSystemOnly() {
      iv_typeSystem->commit();
    }

    CASDefinition::CASDefinition(AnalysisEngineDescription const & taeSpecifier)
        : iv_typeSystem(NULL),
        iv_indexDefinition(NULL),
        iv_annotatorContext(NULL) {

      //resolve imports
      if (taeSpecifier.isModifiable() ) {
        AnalysisEngineDescription & taespec = CONST_CAST(AnalysisEngineDescription &, taeSpecifier);
        taespec.commit();
      }
      iv_typeSystem = new uima::lowlevel::TypeSystem();
      bOwnsTypeSystem = true;
      assert( EXISTS(iv_typeSystem) );
      iv_indexDefinition = new uima::lowlevel::IndexDefinition(*iv_typeSystem);
      assert( EXISTS(iv_indexDefinition) );

    }


    CASDefinition::CASDefinition(uima::TypeSystem  & typeSystem)
        : iv_typeSystem(NULL),
        iv_indexDefinition(NULL),
        iv_annotatorContext(NULL) {
      iv_typeSystem= (uima::lowlevel::TypeSystem*) &typeSystem;
      assert( EXISTS(iv_typeSystem) );
      iv_indexDefinition = new uima::lowlevel::IndexDefinition(*iv_typeSystem);
      assert( EXISTS(iv_indexDefinition) );
      bOwnsTypeSystem = false;
    }


    CASDefinition::CASDefinition()
        : iv_typeSystem(NULL),
        iv_indexDefinition(NULL),
        iv_annotatorContext(NULL) {
      iv_typeSystem = new uima::lowlevel::TypeSystem();
      bOwnsTypeSystem = true;
      assert( EXISTS(iv_typeSystem) );
      iv_indexDefinition = new uima::lowlevel::IndexDefinition(*iv_typeSystem);
      assert( EXISTS(iv_indexDefinition) );

    }


  }
}