void EngineBase::destroyIfNeeded() {
util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE);
try {
if (iv_state == EngineState::enEngineState_readyForProcessOrReconfigOrDeinit) {
destroy();
iv_state.assertMatch(EngineState::enEngineState_readyForDeletion);
}
} catch (ExcWinCException& rclException) {
// windows "exceptions" are really abort signals: we re-throw for app to handle
throw rclException;
} catch (Exception& rclException) {
clTrace.dump("Unexpected UIMACPP exception");
clTrace.dump(rclException.asString().c_str());
assertWithMsg(false, _TEXT(
"Unexpected UIMACPP exception in engine destructor")); //lint !e506: Constant value Boolean
} catch (std::exception& rclException) {
clTrace.dump("ANSI C++ exception");
clTrace.dump(rclException.what());
assertWithMsg(false, _TEXT(
"Unexpected ANSI C++ exception in engine destructor")); //lint !e506: Constant value Boolean
}
#ifdef NDEBUG
catch (...) {
/* this should never occur!!! */
clTrace.dump(_TEXT("Unexpected exception"));
assertWithMsg(false, _TEXT("Unexpected unknown exception in engine destructor")); //lint !e506: Constant value Boolean
}
#endif
}
void BasicArrayFS<T, ARRAY_TYPE>::copyToArray(
size_t uiStart,
size_t uiEnd,
T* destArray,
size_t uiDestOffset) const {
checkValidity(UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY);
checkArraySize(iv_tyFS, iv_cas->getHeap(), uiEnd - uiStart - 1 , UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY);
uima::lowlevel::TyFSType typecode = iv_cas->getHeap()->getType(iv_tyFS);
size_t srcOffset = uiStart;
size_t numelements = uiEnd-uiStart;
size_t destOffset = uiDestOffset;
if (typecode== uima::internal::gs_tyIntArrayType ||
typecode== uima::internal::gs_tyFloatArrayType ) {
iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(uima::lowlevel::TyHeapCell*) destArray,destOffset,numelements);
} else if(typecode== uima::internal::gs_tyByteArrayType ||
typecode== uima::internal::gs_tyBooleanArrayType) {
iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(char*) destArray,destOffset,numelements);
} else if(typecode== uima::internal::gs_tyShortArrayType ) {
iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(short*) destArray,destOffset,numelements);
} else if(typecode== uima::internal::gs_tyLongArrayType ||
typecode== uima::internal::gs_tyDoubleArrayType) {
iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(INT64*) destArray,destOffset,numelements);
} else {
assertWithMsg(false, "Not yet implemented");
UIMA_EXC_THROW_NEW(NotYetImplementedException,
UIMA_ERR_NOT_YET_IMPLEMENTED,
UIMA_MSG_ID_EXC_NOT_YET_IMPLEMENTED,
ErrorMessage(UIMA_MSG_ID_EXCON_UNKNOWN_CONTEXT),
ErrorInfo::unrecoverable
);
}
}
bool randomFilterTest(){
const int SAMPLE_N = 128*1024;
SecureRandomDevice<unsigned int> randomBlock(SAMPLE_N);
std::vector<std::pair<std::string,std::function<bool(unsigned int&)>>> regexCases =
{
{ R"([a-z])", [](unsigned int& i){ return 'a'<=i&&i<='z';}},
{ R"([A-Z])", [](unsigned int& i){ return 'A'<=i&&i<='Z';}},
{ R"([\d!])", [](unsigned int& i){ return ('0'<=i&&i<='9')||(i=='!');}},
{ R"([01])", [](unsigned int& i){ return i=='0'||i=='1';}},
//{ "[]", [](unsigned int& i){ return 'A'<=i&&i<='Z';}},
};
for(auto& i:regexCases){
//print message
std::cout<<i.first<<"\t";
//generate random block
unsigned int* dummy = randomBlock.gen();
//convert it into std::vector and filter it.
std::vector<unsigned int> randomChars(dummy, dummy+SAMPLE_N);
RandomFilter(i.first).filter<unsigned int>(randomChars);
//If there is an character that is not included in the expression, return false.
if(std::find_if_not(randomChars.begin(), randomChars.end(), i.second) != randomChars.end())
return false;
}
return true;
}
#include "intTest.h"
int main(){
assertWithMsg(randomTest);
assertWithMsg(randomFilterTest);
assertWithMsg(integrationTests);
//assertWithMsg([](){ return false; }); //This works.
std::cout<<"All tests were completed successfully. Hooray! :D"<<std::endl;
return 0;
}
inline AnnotatorContext & Annotator::getAnnotatorContext(void) {
assertWithMsg(EXISTS(iv_pclAnnotatorContext), "Annotator::init() Forgot to call 'setAnnotatorContext()'");
return(*iv_pclAnnotatorContext);
}
/*static*/ BasicArrayFS<T, ARRAY_TYPE> BasicArrayFS<T, ARRAY_TYPE>::createArrayFS( CAS & cas, size_t uiSize, bool bIsPermanent) {
assertWithMsg( sizeof(FeatureStructure::TyArrayElement) == sizeof(lowlevel::TyHeapCell), "Port required");
uima::lowlevel::FSHeap & heap = *uima::internal::FSPromoter::getFSHeap(cas);
lowlevel::TyFS tyFS = heap.createArrayFS(ARRAY_TYPE, uiSize);
return BasicArrayFS(internal::FSPromoter::promoteFS( tyFS, cas ));
}
