| /** \file featurestructure.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/featurestructure.hpp" |
| #include "uima/lowlevel_fsheap.hpp" |
| #include "uima/msg.h" |
| #include "uima/internal_fspromoter.hpp" |
| #include "uima/internal_typeshortcuts.hpp" |
| #include "uima/listfs.hpp" |
| #include "uima/arrayfs.hpp" |
| #include "uima/cas.hpp" |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Forward declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| using namespace std; |
| namespace uima { |
| |
| /* |
| Most of the methods in here are thin wrappers over then lowlevel API |
| but also include error checking. |
| */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Exceptions Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| UIMA_EXC_CLASSIMPLEMENT(InvalidFSObjectException, CASException); |
| UIMA_EXC_CLASSIMPLEMENT(FeatureNotAppropriateException, CASException); |
| UIMA_EXC_CLASSIMPLEMENT(IncompatibleValueTypeException, CASException); |
| UIMA_EXC_CLASSIMPLEMENT(FSIsNotStringException, CASException); |
| UIMA_EXC_CLASSIMPLEMENT(WrongStringValueException, CASException); |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Tool Functions Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /** |
| * Checks if this FS is valid and throws an appropriate exeption |
| * with the passed context if not. |
| */ |
| void FeatureStructure::checkValidity(TyMessageId tyContext) const { |
| if (!isValid()) { |
| UIMA_EXC_THROW_NEW(InvalidFSObjectException, |
| UIMA_ERR_INVALID_FS_OBJECT, |
| UIMA_MSG_ID_EXC_INVALID_FS_OBJECT, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| } |
| |
| /** |
| * Checks whether the passed feature is defined on the type of this FS. |
| * Throws an appropriate if not. |
| */ |
| void FeatureStructure::checkFeature(Feature const & f, TyMessageId tyContext) const { |
| if (!f.isValid()) { |
| UIMA_EXC_THROW_NEW(InvalidFSFeatureObjectException, |
| UIMA_ERR_INVALID_FSFEATURE_OBJECT, |
| UIMA_MSG_ID_EXC_INVALID_FSFEATURE_OBJECT, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| assert(EXISTS(iv_cas)); |
| if (! iv_cas->getHeap()->getTypeSystem() |
| .isAppropriateFeature( iv_cas->getHeap()->getType(iv_tyFS), |
| internal::FSPromoter::demoteFeature(f)) ) { |
| ErrorMessage msg(UIMA_MSG_ID_EXC_FEATURE_NOT_APPROPRIATE); |
| UnicodeStringRef ref = f.getName(); |
| icu::UnicodeString usFeatureName( ref.getBuffer(), ref.length() ); |
| msg.addParam( usFeatureName ); |
| msg.addParam( getType().getName() ); |
| |
| UIMA_EXC_THROW_NEW(FeatureNotAppropriateException, |
| UIMA_ERR_FEATURE_NOT_APPROPRIATE, |
| msg, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| } |
| |
| /** |
| * checks if the range type of the feature is not built-in. |
| */ |
| void FeatureStructure::checkNonBuiltinFeature(Feature const & crFeature, TyMessageId tyContext) const { |
| assert(EXISTS(iv_cas)); |
| lowlevel::TypeSystem const & rTS = iv_cas->getHeap()->getTypeSystem(); |
| uima::lowlevel::TyFSType rangeType = rTS.getRangeType(internal::FSPromoter::demoteFeature(crFeature)); |
| if ( rangeType == uima::internal::gs_tyIntegerType |
| || rangeType == uima::internal::gs_tyFloatType |
| || rangeType == uima::internal::gs_tyStringType |
| || rTS.getParentType(rangeType) == uima::internal::gs_tyStringType ) { |
| ErrorMessage msg( UIMA_MSG_ID_EXC_INCOMPATIBLE_RANGE_TYPE); |
| msg.addParam( rTS.getFeatureName( internal::FSPromoter::demoteFeature(crFeature) ) ); |
| Type t; |
| crFeature.getRangeType(t); |
| msg.addParam( t.getName() ); |
| UIMA_EXC_THROW_NEW(FeatureNotAppropriateException, |
| UIMA_ERR_INCOMPATIBLE_RANGE_TYPE, |
| msg, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| } |
| |
| /** |
| * checks if the range type of the feature subsumes the aType. |
| * In other words, checks if an FS of aType is an appropriate value for f. |
| */ |
| void FeatureStructure::checkAppropFeature(Feature const & f, lowlevel::TyFSType aType, TyMessageId tyContext) const { |
| checkFeature(f, tyContext); |
| assert(EXISTS(iv_cas)); |
| uima::lowlevel::TypeSystem const & ts = iv_cas->getHeap()->getTypeSystem(); |
| |
| //This to deal with FS array type with <elementType> tag |
| //which results in a feature range type that is a subtype of |
| //FS array. FSs of type FSArray are allowed values. |
| if (aType == uima::internal::gs_tyFSArrayType) { |
| Type featType; |
| f.getRangeType(featType); |
| lowlevel::TyFSType featTypeCode = internal::FSPromoter::demoteType(featType); |
| if (aType != featTypeCode && !ts.subsumes(aType,featTypeCode) ) { |
| ErrorMessage msg( UIMA_MSG_ID_EXC_INCOMPATIBLE_RANGE_TYPE); |
| msg.addParam( ts.getFeatureName(internal::FSPromoter::demoteFeature(f)) ); |
| msg.addParam( ts.getTypeName(aType) ); |
| UIMA_EXC_THROW_NEW(IncompatibleValueTypeException, |
| UIMA_ERR_INCOMPATIBLE_RANGE_TYPE, |
| msg, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| } else if ( !ts.subsumes(ts.getRangeType(internal::FSPromoter::demoteFeature(f)), aType ) ) { |
| ErrorMessage msg( UIMA_MSG_ID_EXC_INCOMPATIBLE_RANGE_TYPE); |
| msg.addParam( ts.getFeatureName(internal::FSPromoter::demoteFeature(f)) ); |
| msg.addParam( ts.getTypeName(aType) ); |
| UIMA_EXC_THROW_NEW(IncompatibleValueTypeException, |
| UIMA_ERR_INCOMPATIBLE_RANGE_TYPE, |
| msg, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| } |
| |
| /** |
| * checks if anFS is an appropriate value for f. |
| */ |
| void FeatureStructure::checkAppropFeature(Feature const & f, FeatureStructure const & anFS, TyMessageId tyContext) const { |
| if ( (&iv_cas->getHeap()->getTypeSystem()) != (&anFS.iv_cas->getHeap()->getTypeSystem()) ) { |
| UIMA_EXC_THROW_NEW(InvalidFSObjectException, |
| UIMA_ERR_INVALID_FS_OBJECT, |
| UIMA_MSG_ID_EXC_INVALID_FS_OBJECT, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| ); |
| } |
| checkAppropFeature(f, iv_cas->getHeap()->getType(anFS.iv_tyFS), tyContext ); |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* General FeatureStructure Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| FeatureStructure::FeatureStructure(lowlevel::TyFS anFS, CAS & cas) |
| : iv_tyFS(anFS), |
| iv_cas(&cas) {} |
| |
| |
| FeatureStructure::FeatureStructure() |
| : iv_tyFS(0), |
| iv_cas(NULL) {} |
| |
| |
| CAS & FeatureStructure::getCAS() { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FSTYPE); |
| assert(EXISTS(iv_cas)); |
| return *iv_cas; |
| } |
| |
| CAS const & FeatureStructure::getCAS() const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FSTYPE); |
| assert(EXISTS(iv_cas)); |
| return *iv_cas; |
| } |
| |
| bool FeatureStructure::isValid() const { |
| if (! EXISTS(iv_cas) ) { |
| return false; |
| } |
| return iv_tyFS != 0 && ( iv_cas->getHeap()->isValid(iv_tyFS)); |
| } |
| |
| Type FeatureStructure::getType() const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FSTYPE); |
| return uima::internal::FSPromoter::promoteType(iv_cas->getHeap()->getType(iv_tyFS), iv_cas->getHeap()->getTypeSystem() ); |
| } |
| |
| FeatureStructure FeatureStructure::clone() { |
| checkValidity(UIMA_MSG_ID_EXCON_CREATING_FS); |
| FeatureStructure newFS = getCAS().createFS(getType()); |
| iv_cas->getHeap()->copyFeatures(newFS.iv_tyFS, iv_tyFS); |
| return newFS; |
| } |
| |
| FeatureStructure FeatureStructure::clone(Type const & t) { |
| checkValidity(UIMA_MSG_ID_EXCON_CREATING_FS); |
| uima::lowlevel::TypeSystem const & ts = iv_cas->getHeap()->getTypeSystem(); |
| FeatureStructure newFS = getCAS().createFS(t); |
| lowlevel::TyFSType mcst = ts.getMostSpecificCommonSupertype( uima::internal::FSPromoter::demoteType(getType()), |
| uima::internal::FSPromoter::demoteType(t) ); |
| lowlevel::TyFeatureOffset featNum = ts.getFeatureNumber( mcst ); |
| iv_cas->getHeap()->copyFeatures(newFS.iv_tyFS, iv_tyFS, featNum); |
| return newFS; |
| } |
| |
| FeatureStructure FeatureStructure::getFeatureValue(Feature const & f) const { |
| return getFSValue(f); |
| } |
| |
| FeatureStructure FeatureStructure::getFSValue(Feature const & f) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkFeature(f, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkNonBuiltinFeature(f, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( f ); |
| lowlevel::TyFS resultAddr = iv_cas->getHeap()->getFSValue(iv_tyFS, tyFeat); |
| if (resultAddr != uima::lowlevel::FSHeap::INVALID_FS && |
| iv_cas->getHeap()->getTypeSystem().subsumes(internal::gs_tyAnnotationType, |
| internal::FSPromoter::demoteType(internal::FSPromoter::promoteFS(resultAddr, *iv_cas).getType()))) { |
| // an annotation. Check that sofaNum agrees with current CAS |
| lowlevel::TyFS annSofaAddr = iv_cas->getHeap()->getFSValue(resultAddr, internal::gs_tySofaRefFeature); |
| if ( annSofaAddr != internal::FSPromoter::demoteFS(iv_cas->getSofa())) { |
| // does not agree. Get appropriate View for annotation Sofa |
| int annSofaNum = iv_cas->getHeap()->getIntValue(annSofaAddr, internal::gs_tySofaNumFeature); |
| CAS* annTcas = iv_cas->getViewBySofaNum(annSofaNum); |
| return FeatureStructure(resultAddr, (CAS &)*annTcas); |
| } |
| } |
| return FeatureStructure(resultAddr, *iv_cas); |
| } |
| |
| bool FeatureStructure::isUntouchedFSValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkFeature(crFeature, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->isUntouchedFSValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| int FeatureStructure::getIntValue(Feature const & f) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(f, uima::internal::gs_tyIntegerType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getIntValue(iv_tyFS, internal::FSPromoter::demoteFeature(f)); |
| } |
| |
| void FeatureStructure::setFSValue(Feature const & f, FeatureStructure const & anFS) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(f, anFS, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| iv_cas->getHeap()->setFSValue(iv_tyFS, internal::FSPromoter::demoteFeature(f), anFS.iv_tyFS); |
| } |
| |
| void FeatureStructure::setFeatureValue(Feature const & f, FeatureStructure const & anFS) { |
| setFSValue(f, anFS); |
| } |
| |
| void FeatureStructure::setIntValue(Feature const & f, int i) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(f, uima::internal::gs_tyIntegerType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| iv_cas->getHeap()->setIntValue(iv_tyFS, internal::FSPromoter::demoteFeature(f), i); |
| } |
| |
| float FeatureStructure::getFloatValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyFloatType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getFloatValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| void FeatureStructure::setFloatValue(Feature const & crFeature, float f) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyFloatType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| iv_cas->getHeap()->setFloatValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature), f); |
| } |
| |
| bool FeatureStructure::getBooleanValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyBooleanType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getBooleanValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| void FeatureStructure::setBooleanValue(Feature const & crFeature, bool b ) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyBooleanType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| |
| //add byte to 8bit heap |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( crFeature ); |
| iv_cas->getHeap()->setBooleanValue( iv_tyFS, tyFeat, b); |
| } |
| |
| |
| char FeatureStructure::getByteValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyByteType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getByteValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| void FeatureStructure::setByteValue(Feature const & crFeature, char b ) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyByteType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| |
| //add byte to 8bit heap |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( crFeature ); |
| iv_cas->getHeap()->setByteValue( iv_tyFS, tyFeat, b ); |
| } |
| |
| short FeatureStructure::getShortValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyShortType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getShortValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| void FeatureStructure::setShortValue(Feature const & crFeature, short s ) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyShortType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| |
| //add byte to 8bit heap |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( crFeature ); |
| iv_cas->getHeap()->setShortValue( iv_tyFS, tyFeat, s ); |
| } |
| |
| |
| INT64 FeatureStructure::getLongValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyLongType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getLongValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| void FeatureStructure::setLongValue(Feature const & crFeature, INT64 l ) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyLongType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| |
| //add byte to 8bit heap |
| //int aRef = iv_cas->getHeap()->addLong(l); |
| |
| //set the 8bit heap offset in main heap |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( crFeature ); |
| iv_cas->getHeap()->setLongValue( iv_tyFS, tyFeat, l ); |
| } |
| |
| |
| double FeatureStructure::getDoubleValue(Feature const & crFeature) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyDoubleType, UIMA_MSG_ID_EXCON_GETTING_FEATURE_VALUE); |
| return iv_cas->getHeap()->getDoubleValue(iv_tyFS, internal::FSPromoter::demoteFeature(crFeature)); |
| } |
| |
| void FeatureStructure::setDoubleValue(Feature const & crFeature, double d ) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| checkAppropFeature(crFeature, uima::internal::gs_tyDoubleType, UIMA_MSG_ID_EXCON_SETTING_FEATURE_VALUE); |
| |
| //add byte to 8bit heap |
| //int aRef = iv_cas->getHeap()->addDouble(d); |
| |
| //set the 8bit heap offset in main heap |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( crFeature ); |
| iv_cas->getHeap()->setDoubleValue( iv_tyFS, tyFeat, d ); |
| } |
| |
| |
| |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* String-oriented FeatureStructure Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| void FeatureStructure::checkRangeIsString(Feature const & f, TyMessageId tyContext) const { |
| assert(EXISTS(iv_cas)); |
| uima::lowlevel::FSHeap const & crHeap = *iv_cas->getHeap(); |
| uima::lowlevel::TyFSType tyType = crHeap.getTypeSystem().getRangeType(internal::FSPromoter::demoteFeature( f )); |
| if ( ! crHeap.getTypeSystem().subsumes( uima::internal::gs_tyStringType, tyType) ) { |
| UIMA_EXC_THROW_NEW(FSIsNotStringException, |
| UIMA_ERR_FS_IS_NOT_STRING, |
| UIMA_MSG_ID_EXC_FS_IS_NOT_STRING, |
| ErrorMessage(tyContext), |
| ErrorInfo::recoverable |
| |
| ); |
| } |
| } |
| |
| UnicodeStringRef FeatureStructure::getStringValue(Feature const & f) const { |
| checkValidity(UIMA_MSG_ID_EXCON_GETTING_STRINGVALUE_FROM_FS); |
| checkRangeIsString(f, UIMA_MSG_ID_EXCON_GETTING_STRINGVALUE_FROM_FS); |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( f ); |
| lowlevel::TyFS tyStringFS = iv_cas->getHeap()->getFSValue(iv_tyFS, tyFeat); |
| if (tyStringFS == uima::lowlevel::FSHeap::INVALID_FS) { |
| return UnicodeStringRef(); |
| } |
| return iv_cas->getHeap()->getFSAsString( tyStringFS ); |
| } |
| |
| void FeatureStructure::setStringValue(Feature const & f, UnicodeStringRef uls) { |
| setStringValueExternal( f, uls ); |
| } |
| |
| void FeatureStructure::setStringValueExternal(Feature const & f, UnicodeStringRef uls) { |
| checkValidity(UIMA_MSG_ID_EXCON_SETTING_STRINGVALUE_IN_FS); |
| checkRangeIsString(f, UIMA_MSG_ID_EXCON_SETTING_STRINGVALUE_IN_FS); |
| |
| //!!! Not supporting External at this time. All strings added to StringHeap. |
| int ulsRef = iv_cas->getHeap()->addString(uls); |
| lowlevel::TyFSFeature tyFeat = internal::FSPromoter::demoteFeature( f ); |
| |
| uima::lowlevel::TypeSystem const & crTypeSystem = iv_cas->getHeap()->getTypeSystem(); |
| // if string sub type |
| uima::lowlevel::TyFSType tyRangeType = crTypeSystem.getRangeType(tyFeat); |
| if ( tyRangeType != uima::internal::gs_tyStringType) { |
| vector<icu::UnicodeString> const & crStringSet = crTypeSystem.getStringsForStringSubtype(tyRangeType); |
| vector<icu::UnicodeString>::const_iterator cit; |
| bool bStringFound = false; |
| for (cit = crStringSet.begin(); cit != crStringSet.end(); ++cit) { |
| UnicodeStringRef ref(*cit); |
| if ( ref == uls ) { |
| bStringFound = true; |
| break; |
| } |
| } |
| if (! bStringFound) { |
| icu::UnicodeString us(uls.getBuffer(), uls.length() ); |
| ErrorMessage errMess(UIMA_MSG_ID_EXC_WRONG_STRING_VALUE); |
| errMess.addParam(us); |
| errMess.addParam(crTypeSystem.getTypeName(tyRangeType) ); |
| UIMA_EXC_THROW_NEW(WrongStringValueException, |
| UIMA_ERR_WRONG_STRING_VALUE, |
| errMess, |
| ErrorMessage(UIMA_MSG_ID_EXCON_SETTING_STRINGVALUE_IN_FS), |
| ErrorInfo::recoverable); |
| } |
| } |
| |
| |
| |
| iv_cas->getHeap()->setStringValue( iv_tyFS, tyFeat, ulsRef ); |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Array-oriented FeatureStructure Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| ArrayFS FeatureStructure::getArrayFSValue( Feature const & fArray ) const { |
| return ArrayFS(getFSValue(fArray)); |
| } |
| |
| FloatArrayFS FeatureStructure::getFloatArrayFSValue( Feature const & fArray ) const { |
| return FloatArrayFS(getFSValue(fArray)); |
| } |
| |
| IntArrayFS FeatureStructure::getIntArrayFSValue( Feature const & fArray ) const { |
| return IntArrayFS(getFSValue(fArray)); |
| } |
| |
| StringArrayFS FeatureStructure::getStringArrayFSValue( Feature const & fArray ) const { |
| return StringArrayFS(getFSValue(fArray)); |
| } |
| |
| BooleanArrayFS FeatureStructure::getBooleanArrayFSValue( Feature const & fArray ) const { |
| return BooleanArrayFS(getFSValue(fArray)); |
| } |
| |
| ByteArrayFS FeatureStructure::getByteArrayFSValue( Feature const & fArray ) const { |
| return ByteArrayFS(getFSValue(fArray)); |
| } |
| |
| ShortArrayFS FeatureStructure::getShortArrayFSValue( Feature const & fArray ) const { |
| return ShortArrayFS(getFSValue(fArray)); |
| } |
| |
| LongArrayFS FeatureStructure::getLongArrayFSValue( Feature const & fArray ) const { |
| return LongArrayFS(getFSValue(fArray)); |
| } |
| DoubleArrayFS FeatureStructure::getDoubleArrayFSValue( Feature const & fArray ) const { |
| return DoubleArrayFS(getFSValue(fArray)); |
| } |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* List-oriented FeatureStructure Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| bool FeatureStructure::hasListElements(Feature const & f) const { |
| Type tRangeType; |
| f.getRangeType(tRangeType); |
| lowlevel::TyFSFeature tyRangeType = internal::FSPromoter::demoteType(tRangeType); |
| switch (tyRangeType) { |
| case uima::internal::gs_tyFSListType : |
| case uima::internal::gs_tyEListType : |
| case uima::internal::gs_tyNEListType : |
| return ListFS::hasListElements(*this, f); |
| case uima::internal::gs_tyFloatListType : |
| case uima::internal::gs_tyEFloatListType : |
| case uima::internal::gs_tyNEFloatListType : |
| return FloatListFS::hasListElements(*this, f); |
| case uima::internal::gs_tyIntListType : |
| case uima::internal::gs_tyEIntListType : |
| case uima::internal::gs_tyNEIntListType : |
| return IntListFS::hasListElements(*this, f); |
| case uima::internal::gs_tyStringListType : |
| case uima::internal::gs_tyEStringListType : |
| case uima::internal::gs_tyNEStringListType: |
| return StringListFS::hasListElements(*this, f); |
| } |
| UIMA_EXC_THROW_NEW(FSIsNotListException, |
| UIMA_ERR_FS_IS_NOT_LIST, |
| UIMA_MSG_ID_EXC_FS_IS_NOT_LIST, |
| ErrorMessage(UIMA_MSG_ID_EXCON_GETTING_LIST_ISEMPTY), |
| ErrorInfo::recoverable |
| ); |
| return false; |
| } |
| |
| ListFS FeatureStructure::getListFSValue( Feature const & f ) const { |
| return ListFS::getListFSValue(*this, f); |
| } |
| |
| FloatListFS FeatureStructure::getFloatListFSValue( Feature const & f ) const { |
| return FloatListFS::getListFSValue(*this, f); |
| } |
| |
| IntListFS FeatureStructure::getIntListFSValue( Feature const & f ) const { |
| return IntListFS::getListFSValue(*this, f); |
| } |
| |
| StringListFS FeatureStructure::getStringListFSValue( Feature const & f ) const { |
| return StringListFS::getListFSValue(*this, f); |
| } |
| |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Operator FeatureStructure Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| bool FeatureStructure::operator==(FeatureStructure const & crFS) const { |
| return (iv_cas == crFS.iv_cas) && (iv_tyFS == crFS.iv_tyFS); |
| } |
| |
| bool FeatureStructure::operator<(FeatureStructure const & crFS) const { |
| return (iv_cas == crFS.iv_cas) && (iv_tyFS < crFS.iv_tyFS); |
| } |
| |
| } // namespace uima |
| |
| /* ----------------------------------------------------------------------- */ |
| /* <EOF> */ |
| |
