| /** @name annotator.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: |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| -------------------------------------------------------------------------- */ |
| |
| //lint -e625 |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Interface dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #include "uima/annotator.hpp" |
| #include "uima/cas.hpp" |
| |
| #include "uima/msg.h" |
| #include "uima/annotator_context.hpp" |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| //#define DEBUG_VERBOSE |
| #include "uima/trace.hpp" |
| #ifndef NDEBUG |
| #include "uima/envvar.hpp" /* for debugIndicateProcessHasBeenPerformed(); */ |
| #include "uima/envvars.h" /* for debugIndicateProcessHasBeenPerformed(); */ |
| #endif |
| |
| #include "uima/comp_ids.h" |
| #include "uima/resmgr.hpp" |
| |
| #include "uima/capability.hpp" |
| #include "uima/log.hpp" |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| #define UIMA_ANNOTATOR_DELAYED_INFO_NOT_AVAILABLE _TEXT("Information not available for delayed loaded annotator") |
| |
| #define UIMA_ANNOTATOR_DEFAULT_UNSPECIFIED_TERRITORY true |
| #define UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES _TEXT("ProcessUnspecifiedTerritories") |
| |
| |
| using namespace std; |
| /*** |
| #ifndef NDEBUG |
| #define UIMA_ANNOTATOR_INDICATE_PROCESS_FILE_EXTENSION _TEXT(".ind") |
| #endif |
| ***/ |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Globals */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Function declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Macro definitions */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Private Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Public implementation */ |
| /* ----------------------------------------------------------------------- */ |
| namespace uima { |
| UIMA_EXC_CLASSIMPLEMENT(ExcEnumerationOverflow, ExcIllFormedInputError); |
| |
| |
| AnnotatorProxy::AnnotatorProxy(const util::Filename & crclFilename, |
| const TCHAR * cpszSymbolicName, |
| bool bDelayLoad) : |
| iv_clFilename(crclFilename), |
| iv_strSymbolicName(cpszSymbolicName), |
| iv_cpclFile(0), |
| iv_bProcessUnspecifiedTerritories(UIMA_ANNOTATOR_DEFAULT_UNSPECIFIED_TERRITORY), |
| iv_hUserData(0), |
| iv_pAnnotatorContext(NULL) |
| #ifdef DEBUG_ANNOTATOR_TIMING |
| ,iv_clTimerLoad() |
| ,iv_clTimerInit() |
| ,iv_clTimerDeInit() |
| ,iv_clTimerConfig() |
| ,iv_clTimerProcessDocument() |
| ,iv_clTimerBatchProcessComplete() |
| ,iv_clTimerCollectionProcessComplete() |
| #endif |
| /* ----------------------------------------------------------------------- */ |
| { |
| ; |
| } |
| |
| AnnotatorProxy::~AnnotatorProxy(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| |
| |
| if (!isLoadedDelayed()) { |
| unload(); |
| } |
| /* make sure that unload() was performed before call to destructor */ |
| assert(iv_cpclFile == 0); |
| assert(iv_hUserData == (uima::TyHandle) 0); |
| |
| } //lint !e1740: pointer member 'iv_cpclFile' 'iv_hUserData' not directly freed or zero'ed by destructor |
| |
| bool AnnotatorProxy::isValid(void) const |
| /* ----------------------------------------------------------------------- */ |
| { |
| assert(EXISTS(iv_cpclFile)); |
| return(iv_cpclFile->isValid()); |
| } |
| |
| const util::Filename & AnnotatorProxy::getFilename(void) const |
| /* ----------------------------------------------------------------------- */ |
| { |
| if (EXISTS(iv_cpclFile)) { |
| assert(iv_cpclFile->getFilename().matchesBase(iv_clFilename)); |
| |
| return(iv_cpclFile->getFilename()); |
| } else { |
| return(iv_clFilename); |
| } |
| } |
| |
| |
| TyErrorId AnnotatorProxy::load(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailHigh, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerLoad.start()); |
| |
| clTrace.dump(_TEXT("Annotator"), getSymbolicName().c_str()); |
| iv_cpclFile = ResourceManager::getInstance().requestAnnotatorFile(iv_clFilename); |
| assert(EXISTS(iv_cpclFile)); |
| |
| // (Dropped code that set iv_clFilename to name of annotator file without path & extension |
| // as it is not used ... and the filename is no longer changed during the load.) |
| UIMA_ANNOTATOR_TIMING(iv_clTimerLoad.stop()); |
| |
| if (!(EXISTS(iv_cpclFile)) || iv_cpclFile->getErrorId() != UIMA_ERR_NONE) { |
| std::string err = "AnnotatorProxy::load() failed to load "; |
| err += iv_clFilename.getAsCString(); |
| ResourceManager::getInstance().getLogger().logError(err); |
| } |
| return iv_cpclFile->getErrorId(); |
| |
| } |
| |
| TyErrorId AnnotatorProxy::loadDelayed(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| iv_bDelayLoad = false; |
| return(load()); |
| } |
| |
| void AnnotatorProxy::unload(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailHigh, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| if (isLoadedDelayed()) { |
| return; |
| } |
| clTrace.dump(_TEXT("Annotator"), getSymbolicName().c_str()); |
| clTrace.dump("unload..."); |
| |
| //assert(EXISTS(iv_cpclFile)); |
| /* make sure that deInit() was performed before call to unload() */ |
| //assert(NOTEXISTS(iv_hUserData)); |
| iv_cpclFile = 0; |
| } |
| |
| const char* AnnotatorProxy::getErrorMsg() const |
| /* ----------------------------------------------------------------------- */ |
| { |
| if (EXISTS(iv_cpclFile)) |
| return(iv_cpclFile->getErrorMsg()); |
| else |
| return NULL; |
| } |
| |
| TyErrorId AnnotatorProxy::init(AnnotatorContext & rAnnContext) |
| /* ----------------------------------------------------------------------- */ |
| { |
| if (isLoadedDelayed()) { |
| return(init_delayed(rAnnContext)); |
| } else { |
| return(init_now(rAnnContext)); |
| } |
| } |
| |
| TyErrorId AnnotatorProxy::init_delayed(AnnotatorContext & rAnnContext) |
| /* ----------------------------------------------------------------------- */ |
| { |
| assertWithMsg(false, "Never tried"); |
| return UIMA_ERR_NOT_YET_IMPLEMENTED; |
| |
| #ifdef DELAYED_LOADING_ENABLED |
| assert(isLoadedDelayed()); |
| iv_pTCAS = & rTCAS; |
| iv_pAnnotatorContext = & rAnnContext; |
| util::Trace clTrace(util::enTraceDetailHigh, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| // remember address of config control for a later call to init_now |
| // Note: we can't remember the rclConfig itself since it will go out of scope |
| iv_pclDelayConfigCtrl = &rclConfig.getConfigCtrl(); |
| // remember symbolic name for a later call to init_now |
| iv_strDelaySectionHeader = rclConfig.getSymbolicName(); |
| |
| /* Since we can't access the annotator to get enumeration of types/languages |
| etc. we have to assume this info has been specified in the ini file. |
| */ |
| TyErrorId utRetVal = UIMA_ERR_NONE; |
| |
| // the ini value was a comma separated list of type names |
| iv_vecDelayLoadGeneratedTypes.clear(); |
| rclConfig.delayLoadGeneratedTypes(iv_vecDelayLoadGeneratedTypes); |
| // To allow for easier configuration we assume that each type generated |
| // is supported for the "Unspecified-Language" |
| // That way the user has less to specify in the SupportedLanguagesForDelayedLoad |
| // option |
| TyTypenameContainer::iterator itTy1; |
| STL_FOR_EACH(itTy1, iv_vecDelayLoadGeneratedTypes) { |
| vector< Language > & rvecLanguages = iv_vecDelayLoadSupportedLanguages[(*itTy1)]; |
| assert(rvecLanguages.size() == 0); |
| rvecLanguages.push_back(Language(Language::UNSPECIFIED)); |
| } |
| |
| // the ini value was a comma separated list of type names |
| iv_vecDelayLoadRequiredTypes.clear(); |
| rclConfig.delayLoadRequiredTypes(iv_vecDelayLoadRequiredTypes); |
| |
| // the ini value was a comma separated list of type names |
| iv_vecDelayLoadRecommendedTypes.clear(); |
| rclConfig.delayLoadRecommendedTypes(iv_vecDelayLoadRecommendedTypes); |
| |
| TyTypenameContainer vecTemp1; |
| // the ini value was a comma separated list of <type>:<lang>[:<lang>] expressions |
| rclConfig.delayLoadSupportedLanguages(vecTemp1); |
| // now look at each string of the form <type>:<lang>[:<lang>] and parse them |
| // into type and language-list part |
| TyTypenameContainer::const_iterator it1; |
| TyTypenameContainer vecTemp2; |
| TyTypenameContainer::iterator it2; |
| Language clLang(Language::INVALID); |
| STL_FOR_EACH(it1, vecTemp1) { |
| // parse colon (:) delimited list into separate strings |
| vecTemp2.clear(); |
| delimitedString2Vector(vecTemp2, // output vector |
| (*it1), // input string |
| ":", //lint !e918 delimiters : Prototype coercion of pointers |
| true, // trim string flag |
| false // insert empty strings flag |
| ); |
| |
| it2 = vecTemp2.begin(); |
| if (it2 == vecTemp2.end()) { |
| rAnnContext.getLogger().logError(UIMA_ERR_CONFIG_INVALID_OPTION_VALUE, UIMA_CONFIG_ANNOTATOR_DELAY_LOAD_SUPPORTED_LANGUAGES); |
| utRetVal = (TyErrorId)UIMA_ERR_CONFIG_INVALID_OPTION_VALUE; |
| break; |
| } |
| // get a reference to an either an existing entry (created above from |
| // delayLoadGeneratedTypes entries) or create a new and empty one. |
| vector< Language > & rvecLangList = iv_vecDelayLoadSupportedLanguages[(*it2)]; |
| // if it existed as default from above throw away default value and |
| // overwrite with specified stuff from here |
| rvecLangList.clear(); |
| ++it2; |
| for (; it2 != vecTemp2.end(); ++it2) { |
| clLang = Language((*it2)); |
| if (!clLang.isValid()) { |
| rAnnContext.getLogger().logError(UIMA_ERR_CONFIG_INVALID_OPTION_VALUE, UIMA_CONFIG_ANNOTATOR_DELAY_LOAD_SUPPORTED_LANGUAGES); |
| utRetVal = (TyErrorId)UIMA_ERR_CONFIG_INVALID_OPTION_VALUE; |
| break; |
| } |
| rvecLangList.push_back(clLang); |
| } |
| if (utRetVal != UIMA_ERR_NONE) { |
| break; |
| } |
| } |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| |
| return(utRetVal); |
| #endif |
| } |
| |
| TyErrorId AnnotatorProxy::init_now(AnnotatorContext & rAnnotatorContext) |
| /* ----------------------------------------------------------------------- */ |
| { |
| iv_pAnnotatorContext = & rAnnotatorContext; |
| assert(!isLoadedDelayed()); |
| util::Trace clTrace(util::enTraceDetailHigh, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| clTrace.dump(_TEXT("Annotator"), getSymbolicName().c_str()); |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| |
| if (rAnnotatorContext.isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether AnnotatorProxy should be processed for unspecified territories */ |
| (void) rAnnotatorContext.extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| if (iv_bProcessUnspecifiedTerritories) { |
| clTrace.dump(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES _TEXT(" enabled!")); |
| } |
| |
| TyAnnotatorSignatureMakeAE procMaker = (TyAnnotatorSignatureMakeAE) iv_cpclFile->getProcedure("makeAE"); |
| assert(EXISTS(procMaker)); |
| if (NOTEXISTS(procMaker)) { |
| ResourceManager::getInstance().getLogger().logError("AnnotatorProxy::init_now() Could not get procedure makeAE() "); |
| return (UIMA_ERR_ANNOTATOR_MISSING_CREATE); |
| } |
| /* first we need to trigger the creation of the AnnotatorProxy's object ... */ |
| clTrace.dump("CreateAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerInit.start()); |
| iv_hUserData= (procMaker) (); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerInit.stop()); |
| clTrace.dumpAdrs(_TEXT("Annotator Handle"), (const void *) iv_hUserData); //lint !e911 |
| if (NOTEXISTS(iv_hUserData)) { |
| ResourceManager::getInstance().getLogger().logError("AnnotatorProxy::init_now() Could not instantiate annotator "); |
| return(UIMA_ERR_ANNOTATOR_COULD_NOT_CREATE); |
| } |
| /* ... then we initialize the AnnotatorProxy */ |
| clTrace.dump("InitializeAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerInit.start()); |
| //? AnnotatorContext & rclAnnotatorContext = REINTERPRET_CAST(AnnotatorContext &, rclEngine); |
| // AnnotatorContext & rclAnnotatorContext = (AnnotatorContext &) rclEngine; |
| ///utRetVal = (procInit)(rAnnotatorContext, iv_hUserData); |
| iv_hUserData->setAnnotatorContext(rAnnotatorContext); |
| TyErrorId utRetVal = iv_hUserData->initialize(rAnnotatorContext); |
| |
| UIMA_ANNOTATOR_TIMING(iv_clTimerInit.stop()); |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return(utRetVal); |
| } |
| |
| TyErrorId AnnotatorProxy::deInit(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailHigh, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| clTrace.dump(_TEXT("Annotator"), getSymbolicName().c_str()); |
| |
| if (isLoadedDelayed()) { |
| // if we have been delayed until now we have nothing to deinit |
| return(TyErrorId)UIMA_ERR_NONE; |
| } |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| clTrace.dump("DestroyAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerDeInit.start()); |
| TyErrorId utRetVal = iv_hUserData->destroy(); |
| |
| UIMA_ANNOTATOR_TIMING(iv_clTimerDeInit.stop()); |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| /* at this point, the user data may not be used any more */ |
| delete iv_hUserData; |
| iv_hUserData = 0; |
| return(utRetVal); |
| } |
| |
| TyErrorId AnnotatorProxy::typeSystemInit(uima::TypeSystem const & typeSystem) { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| TyErrorId utRetVal = UIMA_ERR_NONE; |
| utRetVal = iv_hUserData->typeSystemInit(typeSystem); |
| return utRetVal; |
| } |
| |
| |
| TyErrorId AnnotatorProxy::reConfig() |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| TyErrorId utRetVal = UIMA_ERR_NONE; |
| |
| // if we are not loaded yet we have nothing to do: the annotator will access |
| // modified configuration once/if it is finaly loaded |
| if (isLoadedDelayed()) { |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return((TyErrorId) utRetVal); |
| } |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| if (iv_pAnnotatorContext->isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether Annotator should be processed for unspecified territories */ |
| (void) iv_pAnnotatorContext->extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| clTrace.dump("ReconfigureAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerConfig.start()); |
| utRetVal = iv_hUserData->reconfigure(); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerConfig.stop()); |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return(utRetVal); |
| } |
| |
| TyErrorId AnnotatorProxy::doProcessDocument(CAS & cas, AnnotatorContext & rAnnContext, ResultSpecification const & crResultSpec) |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| TyErrorId utErrorId = UIMA_ERR_NONE; |
| |
| clTrace.dump(_TEXT("Annotator"), getSymbolicName().c_str()); |
| |
| if (isLoadedDelayed()) { |
| assertWithMsg(false, "Delayed loading could result in errors due to already committed type system!"); |
| #ifdef DELAYED_LOADING_ENABLED |
| utErrorId = loadDelayed(); |
| clTrace.dump(_TEXT("Delayed Load:"), (long)utErrorId); |
| /* could be loaded? */ |
| if (utErrorId != UIMA_ERR_NONE) { |
| rAnnContext.getLogger().logError(utErrorId, getFilename().getAsCString()); //lint !e713: Loss of precision (arg. no. 1) (unsigned long to long) |
| clTrace.dump(_TEXT("Delayed load error"), (long) utErrorId); |
| /**** |
| #ifndef NDEBUG |
| debugIndicateProcessHasBeenPerformed(rTCAS, rAnnContext, utErrorId); |
| #endif |
| ***/ |
| return(utErrorId); |
| } |
| assert(EXISTS(iv_pclDelayConfigCtrl)); |
| /* extract annotator info for symbolic name */ |
| ConfigAnnotator clConfigAnnotator(*iv_pclDelayConfigCtrl, iv_strDelaySectionHeader); |
| utErrorId = clConfigAnnotator.init(); |
| if (utErrorId != UIMA_ERR_NONE) { |
| rAnnContext.getLogger().logError(utErrorId, getFilename().getAsCString()); //lint !e713: Loss of precision (arg. no. 1) (unsigned long to long) |
| clTrace.dump(_TEXT("Delayed config access error"), (long) utErrorId); |
| /*** |
| #ifndef NDEBUG |
| debugIndicateProcessHasBeenPerformed(rTCAS, rAnnContext, utErrorId); |
| #endif |
| ***/ |
| return(utErrorId); |
| } |
| |
| utErrorId = init_now(rAnnContext, clConfigAnnotator); |
| /* could be initialized? */ |
| if (utErrorId != UIMA_ERR_NONE) { |
| rAnnContext.getLogger().logError(utErrorId, getFilename().getAsCString()); //lint !e713: Loss of precision (arg. no. 1) (unsigned long to long) |
| clTrace.dump(_TEXT("Delayed init error"), (long) utErrorId); |
| /*** |
| #ifndef NDEBUG |
| debugIndicateProcessHasBeenPerformed(cas, rAnnContext, utErrorId); |
| #endif |
| ***/ |
| return(utErrorId); |
| } |
| #endif |
| } |
| clTrace.dump("ProcessDocument????"); |
| |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| utErrorId = iv_hUserData->process(cas, crResultSpec); |
| clTrace.dump(_TEXT("rc"), utErrorId); |
| return(utErrorId); |
| } |
| |
| TyErrorId AnnotatorProxy::processDocument(CAS & cas, ResultSpecification const & crResultSpec) |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| TyErrorId utErrorId = UIMA_ERR_NONE; |
| |
| UIMA_ANNOTATOR_TIMING(iv_clTimerProcessDocument.start()); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| utErrorId = doProcessDocument(cas, *iv_pAnnotatorContext, crResultSpec); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerProcessDocument.stop()); |
| return utErrorId; |
| } |
| |
| |
| |
| TyErrorId AnnotatorProxy::batchProcessComplete() |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| TyErrorId utRetVal = UIMA_ERR_NONE; |
| |
| // if we are not loaded yet we have nothing to do: the annotator will access |
| // modified configuration once/if it is finaly loaded |
| if (isLoadedDelayed()) { |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return((TyErrorId) utRetVal); |
| } |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| if (iv_pAnnotatorContext->isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether Annotator should be processed for unspecified territories */ |
| (void) iv_pAnnotatorContext->extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| /* pass control to the Annotator */ |
| clTrace.dump("BatchprocessingcompleteAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerBatchProcessComplete.start()); |
| utRetVal = iv_hUserData->batchProcessComplete(); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerBatchProcessComplete.stop()); |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return(utRetVal); |
| } |
| |
| TyErrorId AnnotatorProxy::collectionProcessComplete() |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| TyErrorId utRetVal = UIMA_ERR_NONE; |
| |
| // if we are not loaded yet we have nothing to do: the annotator will access |
| // modified configuration once/if it is finaly loaded |
| if (isLoadedDelayed()) { |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return((TyErrorId) utRetVal); |
| } |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| if (iv_pAnnotatorContext->isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether Annotator should be processed for unspecified territories */ |
| (void) iv_pAnnotatorContext->extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| clTrace.dump("CollectionprocessingcompleteAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerCollectionProcessComplete.start()); |
| utRetVal = iv_hUserData->collectionProcessComplete(); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerCollectionProcessComplete.stop()); |
| clTrace.dump(_TEXT("rc"), utRetVal); |
| return(utRetVal); |
| } |
| |
| |
| bool AnnotatorProxy::hasNext() |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| // if we are not loaded yet we have nothing to do: the annotator will access |
| // modified configuration once/if it is finaly loaded |
| if (isLoadedDelayed()) { |
| return false; |
| } |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| if (iv_pAnnotatorContext->isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether Annotator should be processed for unspecified territories */ |
| (void) iv_pAnnotatorContext->extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| clTrace.dump("HasnextAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerHasNext.start()); |
| bool hasNext = iv_hUserData->hasNext(); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerHasNext.stop()); |
| |
| return(hasNext); |
| } |
| |
| |
| CAS & AnnotatorProxy::next() |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| // if we are not loaded yet we have nothing to do: the annotator will access |
| // modified configuration once/if it is finaly loaded |
| /** why do this check (bi) |
| if (isLoadedDelayed()) { |
| return NULL; |
| } **/ |
| |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| if (iv_pAnnotatorContext->isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether Annotator should be processed for unspecified territories */ |
| (void) iv_pAnnotatorContext->extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| clTrace.dump("NextAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerHasNext.start()); |
| CAS & cas = iv_hUserData->next(); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerHasNext.stop()); |
| |
| return(cas); |
| } |
| |
| int AnnotatorProxy::getCasInstancesRequired() |
| /* ----------------------------------------------------------------------- */ |
| { |
| util::Trace clTrace(util::enTraceDetailMedium, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ANNOTATOR_MGR); |
| |
| // if we are not loaded yet we have nothing to do: the annotator will access |
| // modified configuration once/if it is finaly loaded |
| if (isLoadedDelayed()) { |
| |
| return 0; |
| } |
| assert(EXISTS(iv_cpclFile)); |
| assert(iv_cpclFile->isValid()); |
| assert(EXISTS(iv_hUserData)); |
| assert( EXISTS(iv_pAnnotatorContext) ); |
| if (iv_pAnnotatorContext->isParameterDefined(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES)) { |
| /* optionally, check whether Annotator should be processed for unspecified territories */ |
| (void) iv_pAnnotatorContext->extractValue(UIMA_CONFIG_ANNOTATOR_PROCESS_UNSPECIFIED_TERRITORIES, iv_bProcessUnspecifiedTerritories); |
| } |
| clTrace.dump("GetcasinstancesrequiredAnnotator..."); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerHasNext.start()); |
| int max = iv_hUserData->getCasInstancesRequired(); |
| UIMA_ANNOTATOR_TIMING(iv_clTimerHasNext.stop()); |
| |
| return(max); |
| } |
| |
| } |
| /* <EOF> */ |
| |
| |
