| /** \file annotator_abase.hpp . |
| ----------------------------------------------------------------------------- |
| |
| |
| |
| * 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. |
| |
| ----------------------------------------------------------------------------- |
| |
| \brief Contains Annotator a abstract base class four the Annotator object |
| |
| Description: |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| -------------------------------------------------------------------------- */ |
| |
| #ifndef UIMA_ANNOTATOR_ABASE_HPP |
| #define UIMA_ANNOTATOR_ABASE_HPP |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Interface dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #include "uima/pragmas.hpp" // must be first file to be included to get pragmas |
| ////#include "uima/annotator_api.h" |
| #include "uima/cas.hpp" |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Forward declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| namespace uima { |
| class AnnotatorContext; // forward declaration |
| class ResultSpecification; |
| class TCAS; |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| |
| namespace uima { |
| /** |
| * The class <TT>Annotator</TT> defines the API methods an |
| * annotator must implement. |
| */ |
| class Annotator { //lint -esym(1512, Annotator ) destructor for base class Annotator is not virtual |
| public: |
| Annotator(void); |
| virtual ~Annotator() { |
| ; |
| } |
| |
| /** |
| * set the AnnotatorContext. |
| * |
| * This function need not be called by the annotator code. |
| */ |
| void setAnnotatorContext(AnnotatorContext & rclAnnotatorContext); |
| |
| /** get the annotator context of this annotator. */ |
| AnnotatorContext & getAnnotatorContext(void); |
| |
| /** @name Annotator Processing Functions */ |
| /*@{*/ |
| |
| /** Call the annotator to initialize itself based on an AnnotatorContext. */ |
| virtual |
| TyErrorId initialize(AnnotatorContext & rclAnnotatorContext) = 0; |
| |
| /** |
| * Call the annotator to cache type/feature objects used in subsequent process() calls. |
| */ |
| virtual |
| TyErrorId typeSystemInit(TypeSystem const &) = 0; |
| |
| /** Call the annotator to deinitialize itself. |
| */ |
| virtual |
| TyErrorId destroy(void) = 0; |
| |
| /** Call the annotator to reconfigure itself.(optional method) |
| */ |
| virtual TyErrorId reconfigure(); |
| |
| /** Call the annotator to perform its task with |
| * a ResultSpecification indicating what (sub)set of the capabilities |
| * of the annotator are actually needed. This method should only be |
| * called with an instance of Annotator. It should not be called with |
| * an instance of a TextAnnotator as the TextAnnotator works with a TCAS |
| * view of the CAS. |
| */ |
| virtual |
| TyErrorId process(CAS & cas, ResultSpecification const & crResultSpecification) = 0; |
| |
| |
| /** Call the annotator to perform a batchProcessComplete operation. */ |
| virtual TyErrorId batchProcessComplete(); |
| |
| /** Call the annotator to perform a collectionProcessComplete operation. */ |
| virtual TyErrorId collectionProcessComplete(); |
| |
| /** Call the annotator to perform a hasNext operation to determine whether |
| * this analysis component will be returning new CASs. */ |
| virtual bool hasNext(); |
| |
| /** Call the annotator to retrieve the next CAS if hasNext() has returned true. */ |
| virtual CAS & next(); |
| |
| /** Call the annotator to get the number of CAS instances it will use |
| * concurrently in order to determine the size of the CASPool for this component. */ |
| virtual int getCasInstancesRequired(); |
| |
| /*@}*/ |
| private: |
| AnnotatorContext * iv_pclAnnotatorContext; |
| TypeSystem const * iv_typeSystem; |
| } |
| ; /* Annotator */ |
| |
| |
| /** @deprecated |
| * A TextAnnotator is an Annotator which can process text documents. |
| * In other words, it operates on a TCAS. |
| */ |
| class TextAnnotator : public Annotator { |
| public: |
| TextAnnotator(); |
| virtual ~TextAnnotator() { } |
| |
| virtual TyErrorId process(CAS & cas, ResultSpecification const & crResultSpecification); |
| }; |
| |
| |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| inline Annotator::Annotator(void) : |
| iv_pclAnnotatorContext(NULL), |
| iv_typeSystem(NULL) { |
| ; |
| } |
| |
| inline TyErrorId Annotator::reconfigure() { |
| return (TyErrorId)UIMA_ERR_NONE; |
| } |
| |
| inline TyErrorId Annotator::batchProcessComplete() { |
| return (TyErrorId)UIMA_ERR_NONE; |
| } |
| |
| inline TyErrorId Annotator::collectionProcessComplete() { |
| return (TyErrorId)UIMA_ERR_NONE; |
| } |
| |
| inline bool Annotator::hasNext() { |
| return false; |
| } |
| |
| inline CAS & Annotator::next() { |
| |
| UIMA_EXC_THROW_NEW(ExcInvalidRequest, |
| UIMA_ERR_NOT_YET_IMPLEMENTED, |
| UIMA_MSG_ID_EXC_INVALID_CALL_TO_NEXT, |
| UIMA_MSG_ID_EXC_INVALID_CALL_TO_NEXT, |
| ErrorInfo::unrecoverable); |
| } |
| |
| inline int Annotator::getCasInstancesRequired() { |
| return 0; |
| } |
| |
| inline void Annotator::setAnnotatorContext(AnnotatorContext & rclAnnotatorContext) { |
| iv_pclAnnotatorContext = &rclAnnotatorContext; |
| } |
| |
| inline AnnotatorContext & Annotator::getAnnotatorContext(void) { |
| assertWithMsg(EXISTS(iv_pclAnnotatorContext), "Annotator::init() Forgot to call 'setAnnotatorContext()'"); |
| return(*iv_pclAnnotatorContext); |
| } |
| |
| |
| ///////////////////////////////////////// |
| |
| inline TextAnnotator::TextAnnotator() |
| : Annotator() {} |
| |
| inline TyErrorId TextAnnotator::process(CAS & cas, ResultSpecification const & crResultSpecification) { |
| // CAS & tcas = CAS::promoteCAS(cas); |
| return process(cas, crResultSpecification); |
| } |
| |
| /** MAKE_AE macro must be used by UIMA component writers |
| to export an entry point to the component */ |
| #define MAKE_AE(classAE) extern "C" UIMA_ANNOTATOR_LINK_IMPORTSPEC Annotator * makeAE() { return new classAE; } |
| |
| extern "C" UIMA_ANNOTATOR_LINK_IMPORTSPEC Annotator * makeAE(); |
| |
| |
| } |
| |
| #endif /* UIMA_ANNOTATOR_ABASE_HPP */ |
| |
| /* <EOF> */ |
| |