| /** \file annotator_context.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. |
| |
| ----------------------------------------------------------------------------- |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| -------------------------------------------------------------------------- */ |
| #include "uima/pragmas.hpp" //must be included first to disable warnings |
| #include "uima/err_ids.h" |
| #include "uima/msg.h" |
| #include "uima/log.hpp" |
| #include "uima/annotator_context.hpp" |
| #include "uima/taespecifier.hpp" |
| #include "uima/config_param.hpp" |
| #include "uima/taespecifierbuilder.hpp" |
| #include "uima/internal_casimpl.hpp" |
| |
| using namespace std; |
| namespace uima { |
| |
| #define CTX_DEFAULT_TEXT_SOFA_NAME "_DefaultTextSofaName" |
| |
| AnnotatorContext::AnnotatorContext(AnalysisEngineDescription * delegateSpec, |
| AnnotatorContext * parent, |
| const icu::UnicodeString & ancKey) |
| :iv_pParentAnC(parent), iv_AnCKey(ancKey), |
| iv_pTaeSpecifier(delegateSpec), iv_mapDelegateAncs(), iv_pCasPool(NULL) { |
| buildDelegateAnCs(); |
| iv_pLogger = new LogFacility( delegateSpec->getAnalysisEngineMetaData()->getName() ); |
| assert(EXISTS(iv_pLogger) ); |
| bOwnsTaeSpecifier=false; |
| } |
| |
| AnnotatorContext::AnnotatorContext(AnalysisEngineDescription * taeSpec) |
| :iv_pParentAnC(NULL), iv_AnCKey(""), iv_pTaeSpecifier(taeSpec), |
| iv_mapDelegateAncs(), iv_pCasPool(NULL) { |
| buildDelegateAnCs(); |
| iv_pLogger = new LogFacility( taeSpec->getAnalysisEngineMetaData()->getName() ); |
| assert(EXISTS(iv_pLogger) ); |
| bOwnsTaeSpecifier=false; |
| } |
| |
| |
| |
| AnnotatorContext::AnnotatorContext(AnalysisEngineDescription * delegateSpec, |
| AnnotatorContext * parent, |
| const icu::UnicodeString & ancKey, |
| const AnalysisEngineDescription::TyVecpSofaMappings & vecSofaMappings) |
| :iv_pParentAnC(parent), iv_AnCKey(ancKey), |
| iv_pTaeSpecifier(delegateSpec), iv_mapDelegateAncs(), iv_pCasPool(NULL) { |
| //process the sofa mappings |
| AnalysisEngineDescription::TyVecpSofaMappings::const_iterator iter; |
| |
| for (iter = vecSofaMappings.begin(); iter != vecSofaMappings.end(); ++iter) { |
| SofaMapping * sofamap = * iter; |
| //if this sofamapping is for this context |
| if (sofamap->getComponentKey().compare(ancKey) == 0) { |
| // add mapping to this context sofa mapping |
| // where component sofa name is the key and |
| // aggregate sofaname is the value |
| // if component sofa name is not set, |
| // set it to the default for tcas sofas. |
| if (sofamap->getComponentSofaName().length() == 0) { |
| icu::UnicodeString ustr(CAS::NAME_DEFAULT_TEXT_SOFA); |
| sofamap->setComponentSofaName(ustr); |
| } |
| SofaID * pSofaid = new SofaID(); |
| pSofaid->setSofaId(sofamap->getAggregateSofaName()); |
| pSofaid->setComponentSofaName(sofamap->getComponentSofaName()); |
| icu::UnicodeString astr = sofamap->getComponentSofaName(); |
| iv_mapSofaMappings[astr] = pSofaid; |
| |
| //if this delegate is an aggregate and has sofamapping |
| //check if somponent sofaname is specified as the |
| //aggregate sofa name in this delegate specifier |
| //if so update that aggregate sofa name |
| if (!delegateSpec->isPrimitive()) { |
| AnalysisEngineDescription::TyVecpSofaMappings delegateSofaMappings = delegateSpec->getSofaMappings(); |
| if (delegateSofaMappings.size() > 0 ) { |
| AnalysisEngineDescription::TyVecpSofaMappings::const_iterator iter; |
| |
| for (iter = delegateSofaMappings.begin(); iter != delegateSofaMappings.end(); ++iter) { |
| SofaMapping * delsofamap = * iter; |
| if (delsofamap->getAggregateSofaName().compare(astr)==0) { |
| delsofamap->setAggregateSofaName(pSofaid->getSofaId()); |
| } |
| } |
| |
| |
| } |
| } |
| |
| |
| } |
| |
| } |
| |
| buildDelegateAnCs(); |
| |
| iv_pLogger = new LogFacility( delegateSpec->getAnalysisEngineMetaData()->getName() ); |
| assert(EXISTS(iv_pLogger) ); |
| bOwnsTaeSpecifier=false; |
| } |
| |
| |
| AnnotatorContext::~AnnotatorContext(void) { |
| TyMapDelegateAnCs::iterator ite; |
| for (ite=iv_mapDelegateAncs.begin(); ite != iv_mapDelegateAncs.end(); ite++) { |
| delete (ite->second); |
| } |
| //BSI |
| TyMapSofaMappings::iterator ite2; |
| for (ite2=iv_mapSofaMappings.begin(); ite2 != iv_mapSofaMappings.end(); ite2++) { |
| delete (ite2->second); |
| } |
| |
| if (EXISTS(iv_pLogger) ) |
| delete iv_pLogger; |
| |
| if (bOwnsTaeSpecifier) { |
| delete iv_pTaeSpecifier; |
| } |
| |
| if (iv_pCasPool != NULL) { |
| delete iv_pCasPool; |
| } |
| } |
| |
| |
| CAS & AnnotatorContext::getEmptyCAS() { |
| |
| if (iv_pCasPool) |
| return iv_pCasPool->getCAS(); |
| else { |
| UIMA_EXC_THROW_NEW(CASPoolException, |
| UIMA_ERR_CASPOOL_CREATE_CAS, |
| UIMA_MSG_ID_EXC_CREATE_CASPOOL, |
| UIMA_MSG_ID_EXC_CREATE_CASPOOL, |
| ErrorInfo::unrecoverable); |
| } |
| } |
| |
| void AnnotatorContext::releaseCAS(CAS & aCas) { |
| if (iv_pCasPool) |
| iv_pCasPool->releaseCAS(aCas); |
| } |
| |
| TyErrorId AnnotatorContext::defineCASPool(size_t numInstances) { |
| iv_pCasPool = new CASPool(getTaeSpecifier(),numInstances); |
| if (iv_pCasPool == NULL) { |
| return UIMA_ERR_USER_ANNOTATOR_OUT_OF_MEMORY; |
| } |
| return UIMA_ERR_NONE; |
| } |
| |
| AnnotatorContext * AnnotatorContext::getDelegate(const icu::UnicodeString & key) const { |
| TyMapDelegateAnCs::const_iterator ite = iv_mapDelegateAncs.find(key); |
| if (ite != iv_mapDelegateAncs.end()) { |
| return ite->second; |
| } else { |
| return NULL; |
| } |
| } |
| |
| AnnotatorContext * AnnotatorContext::extractDelegate(const icu::UnicodeString & key) { |
| TyMapDelegateAnCs::iterator ite = iv_mapDelegateAncs.find(key); |
| if (ite != iv_mapDelegateAncs.end()) { |
| AnnotatorContext * anCon = ite->second; |
| iv_mapDelegateAncs.erase(ite); |
| return anCon; |
| } else { |
| return NULL; |
| } |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const bool & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::BOOLEAN, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const vector< bool > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::BOOLEAN, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const int & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const vector< int > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const size_t & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue((int)value); |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const vector< size_t > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue((int)values[i]); |
| } |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const float & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const vector< float > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const double & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue((float)value); |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const vector< double > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue((float)values[i]); |
| } |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const icu::UnicodeString & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::STRING, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & paramName, |
| const vector< icu::UnicodeString > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::STRING, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i <values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const bool & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::BOOLEAN, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const vector< bool > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::BOOLEAN, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const int & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const vector< int > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const size_t & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue((int)value); |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const vector< size_t > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::INTEGER, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue((int)values[i]); |
| } |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const float & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const vector< float > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const double & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue((float)value); |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const vector< double > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::FLOAT, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i < values.size(); i++) { |
| nvPair.addValue((float)values[i]); |
| } |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const icu::UnicodeString & value) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::STRING, ConfigurationParameter::SINGLE_VALUE); |
| nvPair.setValue(value); |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| TyErrorId AnnotatorContext::assignValue(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| const vector< icu::UnicodeString > & values) { |
| NameValuePair nvPair; |
| nvPair.setName(paramName); |
| nvPair.define(ConfigurationParameter::STRING, ConfigurationParameter::MULTIPLE_VALUES); |
| for (size_t i=0; i <values.size(); i++) { |
| nvPair.addValue(values[i]); |
| } |
| return setNameValuePair(groupName, nvPair); |
| } |
| |
| const AnalysisEngineMetaData::TyVecpFSIndexDescriptions AnnotatorContext::getFSIndexDescriptions() const { |
| AnalysisEngineMetaData::TyVecpFSIndexDescriptions allDescs; |
| const AnalysisEngineMetaData::TyVecpFSIndexDescriptions & myDescs = |
| iv_pTaeSpecifier->getAnalysisEngineMetaData()->getFSIndexDescriptions(); |
| size_t i; |
| for (i=0; i < myDescs.size(); i++) { |
| allDescs.push_back(myDescs[i]); |
| } |
| TyMapDelegateAnCs::const_iterator ite; |
| for (ite=iv_mapDelegateAncs.begin(); ite != iv_mapDelegateAncs.end(); ite++) { |
| const AnalysisEngineMetaData::TyVecpFSIndexDescriptions & delDesc = ite->second->getFSIndexDescriptions(); |
| for (i=0; i < delDesc.size(); i++) { |
| allDescs.push_back(delDesc[i]); |
| } |
| } |
| return allDescs; |
| } |
| |
| NameValuePair const * |
| AnnotatorContext::findNameValuePair(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName, |
| AnalysisEngineMetaData::EnSearchStrategy strategy, |
| const icu::UnicodeString & ancKey) const { |
| NameValuePair const * pValueLocal = iv_pTaeSpecifier->getNameValuePair(groupName, paramName, strategy, ancKey); |
| |
| // the request was invalid we got an exception we leave to others to catch |
| |
| //now check whether the parent has the value as well |
| if (EXISTS(iv_pParentAnC)) {//if it's not the top-most AnC |
| //if the parent has the value, errId and nvPair will be set correctly |
| NameValuePair const * pValueParent = NULL; |
| try { |
| pValueParent = iv_pParentAnC->findNameValuePair(groupName, paramName, strategy, iv_AnCKey); |
| } catch (ConfigException e) { |
| // a parameter may not even be defined at our parent AnC |
| // but this is not an error - so we just continue |
| assert(pValueParent == NULL); |
| } |
| if (pValueParent != NULL) { |
| return pValueParent; |
| } |
| //otherwise, nvPair will still contain the NameValuePair found in this AnC |
| //(or is still not set, if this AnC doesn't have the value) |
| } |
| return pValueLocal; |
| } |
| |
| /** |
| * Almost clone of <code>findNameValuePair</code> with 4 params. |
| * Reason for cloning: we have to call a different <code>findNameValuePair</code> of the |
| * parent than in the other version, i.e. one that returns the default value of the parent, not |
| * the value in the parent of the default group of this AnC. |
| **/ |
| NameValuePair const * AnnotatorContext::findNameValuePair(const icu::UnicodeString & paramName, |
| const icu::UnicodeString & ancKey) const { |
| /* return findNameValuePair(getGroupNameWhenNotSpec(), paramName, iv_pTaeSpecifier->getSearchStrategy()); */ |
| NameValuePair const * pValueLocal = pValueLocal = iv_pTaeSpecifier->getNameValuePair(paramName, ancKey); |
| |
| // the request was invalid we got an exception we leave to others to catch |
| |
| //now check whether the parent has the value as well |
| if (EXISTS(iv_pParentAnC)) {//if it's not the top-most AnC |
| //if the parent has the value, errId and nvPair will be set correctly |
| NameValuePair const * pValueParent = NULL; |
| try { |
| pValueParent = iv_pParentAnC->findNameValuePair(paramName, iv_AnCKey); |
| } catch (ConfigException e) { |
| // a parameter may not even be defined at our parent AnC |
| // but this is not an error - so we just continue |
| assert(pValueParent == NULL); |
| } |
| if (pValueParent != NULL) { |
| return pValueParent; |
| } |
| //otherwise, nvPair will still contain the NameValuePair found in this AnC |
| //(or is still not set, if this AnC doesn't have the value) |
| } |
| return pValueLocal; |
| } |
| |
| TyErrorId AnnotatorContext::setNameValuePair(const NameValuePair & nvPair) { |
| |
| TyErrorId errId=UIMA_ERR_CONFIG_INVALID_PARAM_NAME; |
| if (EXISTS(iv_pParentAnC)) { |
| errId = iv_pParentAnC->setNameValuePair(nvPair); |
| } |
| |
| if (errId != UIMA_ERR_NONE) {//there's either no parent or the nvPair couldn't be set at the parent |
| errId = iv_pTaeSpecifier->setNameValuePair(nvPair); |
| } |
| return errId; |
| } |
| |
| TyErrorId AnnotatorContext::setNameValuePair(const icu::UnicodeString & groupName, |
| const NameValuePair & nvPair) { |
| |
| TyErrorId errId=UIMA_ERR_CONFIG_INVALID_PARAM_NAME; |
| if (EXISTS(iv_pParentAnC)) { |
| errId = iv_pParentAnC->setNameValuePair(groupName, nvPair); |
| } |
| |
| if (errId != UIMA_ERR_NONE) {//there's either no parent or the nvPair couldn't be set at the parent |
| errId = iv_pTaeSpecifier->setNameValuePair(groupName, nvPair); |
| } |
| return errId; |
| } |
| |
| void AnnotatorContext::buildDelegateAnCs() { |
| |
| assert(EXISTS(iv_pTaeSpecifier)); |
| const AnalysisEngineDescription::TyMapDelegateSpecs & delegateTaes = iv_pTaeSpecifier->getDelegates(); |
| AnalysisEngineDescription::TyMapDelegateSpecs::const_iterator ite; |
| |
| vector < icu::UnicodeString > delegateNames; |
| for (ite = delegateTaes.begin(); ite != delegateTaes.end(); ite++) { |
| delegateNames.push_back(ite->first); |
| } |
| |
| size_t i; |
| for (i=0; i < delegateNames.size(); i++) { |
| //AnalysisEngineDescription * delSpec = iv_pTaeSpecifier->extractDelegate(delegateNames[i]); |
| AnalysisEngineDescription * delSpec = iv_pTaeSpecifier->getDelegate(delegateNames[i]); |
| //BSI: AnnotatorContext * delegateAnc = new AnnotatorContext(delSpec, this, delegateNames[i]); |
| AnnotatorContext * delegateAnc = new AnnotatorContext(delSpec, this, |
| delegateNames[i], |
| iv_pTaeSpecifier->getSofaMappings()); |
| iv_mapDelegateAncs [delegateNames[i]] = delegateAnc; |
| } |
| } |
| |
| bool AnnotatorContext::isParameterDefined(const icu::UnicodeString & paramName) const { |
| AnalysisEngineMetaData const * pMetaData = getTaeSpecifier().getAnalysisEngineMetaData(); |
| |
| assert(EXISTS(pMetaData)); |
| return pMetaData->isParameterDefined(paramName, ""); |
| } |
| |
| bool AnnotatorContext::isParameterDefined(const icu::UnicodeString & groupName, |
| const icu::UnicodeString & paramName) const { |
| AnalysisEngineMetaData const * pMetaData = getTaeSpecifier().getAnalysisEngineMetaData(); |
| assert(EXISTS(pMetaData)); |
| return pMetaData->isParameterDefined(groupName, paramName, ""); |
| } |
| |
| |
| const set <icu::UnicodeString> AnnotatorContext::getGroupNamesForParameter(const icu::UnicodeString & paramName) const { |
| set <icu::UnicodeString> groupNames; |
| AnalysisEngineMetaData const * pMetaData = getTaeSpecifier().getAnalysisEngineMetaData(); |
| |
| assert(EXISTS(pMetaData)); |
| |
| if (EXISTS(iv_pParentAnC) && pMetaData->hasGroups()) { |
| groupNames = iv_pParentAnC->getGroupNamesForParameter(paramName); |
| } |
| vector <icu::UnicodeString> localGroups = pMetaData->getGroupNamesForParameter(paramName); |
| vector <icu::UnicodeString>::const_iterator ite; |
| for (ite = localGroups.begin(); ite != localGroups.end(); ite++) { |
| groupNames.insert(*ite); |
| } |
| return groupNames; |
| } |
| |
| // These 2 are not inlined so they'll use the uima library's heap which is what |
| // the extractValue methods appear to use, even though they are declared inline. |
| |
| void AnnotatorContext::release(std::string & value) const { |
| value.clear(); |
| } |
| |
| void AnnotatorContext::release(vector<std::string*> & returnValues) const { |
| for (size_t i=0; i < returnValues.size();i++) { |
| delete returnValues.at(i); |
| } |
| returnValues.clear(); |
| } |
| |
| } // namespace uima |
