Author: bhavani Date: Tue Dec 20 13:00:06 2011 New Revision: 1221237 URL: http://svn.apache.org/viewvc?rev=1221237&view=rev Log: UIMA-2307 implement copyToArray and copyFromArray in class BasicArrayFS
Modified: uima/uimacpp/trunk/src/cas/arrayfs.cpp uima/uimacpp/trunk/src/cas/uima/lowlevel_fsheap.hpp uima/uimacpp/trunk/src/test/src/test_primitivetypes.cpp Modified: uima/uimacpp/trunk/src/cas/arrayfs.cpp URL: http://svn.apache.org/viewvc/uima/uimacpp/trunk/src/cas/arrayfs.cpp?rev=1221237&r1=1221236&r2=1221237&view=diff ============================================================================== --- uima/uimacpp/trunk/src/cas/arrayfs.cpp (original) +++ uima/uimacpp/trunk/src/cas/arrayfs.cpp Tue Dec 20 13:00:06 2011 @@ -169,28 +169,76 @@ namespace uima { size_t uiEnd, T* destArray, size_t uiDestOffset) const { - 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 - ); + checkValidity(UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY); + checkArraySize(iv_tyFS, iv_cas->getHeap(), uiEnd - uiStart , UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY); + uima::lowlevel::TyFSType typecode = iv_cas->getHeap()->getType(iv_tyFS); + T result; + size_t srcOffset = uiStart; + size_t numelements = uiEnd-uiStart+1; + 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 + ); + } } - template< class T, const uima::lowlevel::TyFSType ARRAY_TYPE > void BasicArrayFS<T, ARRAY_TYPE>::copyFromArray( - T const * sourceArray, + T const * sourceArray, size_t uiStart, size_t uiEnd, size_t uiOffset) { - 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 - ); + checkValidity(UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY); + checkArraySize(iv_tyFS, iv_cas->getHeap(), uiEnd - uiStart, UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY); + + size_t srcOffset = uiStart; + size_t numelements = uiEnd-uiStart+1; + size_t destOffset = uiOffset; + checkArraySize(iv_tyFS, iv_cas->getHeap(), destOffset+numelements-1, UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY); + uima::lowlevel::TyFSType typecode = iv_cas->getHeap()->getType(iv_tyFS); + + if (typecode== uima::internal::gs_tyIntArrayType || + typecode== uima::internal::gs_tyFloatArrayType ) { + iv_cas->getHeap()->copyFromArray( (uima::lowlevel::TyHeapCell *) sourceArray, srcOffset, iv_tyFS, destOffset, numelements); + } + else if(typecode== uima::internal::gs_tyByteArrayType || + typecode== uima::internal::gs_tyBooleanArrayType ) { + iv_cas->getHeap()->copyFromArray( (char *) sourceArray, srcOffset, iv_tyFS, destOffset, numelements); + + } + else if(typecode== uima::internal::gs_tyShortArrayType) { + iv_cas->getHeap()->copyFromArray( (short *) sourceArray, srcOffset, iv_tyFS, destOffset, numelements); + } + else if(typecode== uima::internal::gs_tyLongArrayType || + typecode == uima::internal::gs_tyDoubleArrayType ) { + iv_cas->getHeap()->copyFromArray( (INT64 *) sourceArray, srcOffset, iv_tyFS, 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 + ); + + } } template< class T, const uima::lowlevel::TyFSType ARRAY_TYPE > Modified: uima/uimacpp/trunk/src/cas/uima/lowlevel_fsheap.hpp URL: http://svn.apache.org/viewvc/uima/uimacpp/trunk/src/cas/uima/lowlevel_fsheap.hpp?rev=1221237&r1=1221236&r2=1221237&view=diff ============================================================================== --- uima/uimacpp/trunk/src/cas/uima/lowlevel_fsheap.hpp (original) +++ uima/uimacpp/trunk/src/cas/uima/lowlevel_fsheap.hpp Tue Dec 20 13:00:06 2011 @@ -609,6 +609,63 @@ namespace uima { bool getBoolean(TyHeapCell offset ); INT64 getLong(TyHeapCell offset); double getDouble(TyHeapCell offset); + + + void FSHeap::copyFromArray(TyHeapCell sourceArray[], size_t srcOffset, TyHeapCell tyCell, size_t destOffset, size_t numelements) { + TyHeapCell * ptr = getCArrayFromFS(tyCell); + if(ptr!=NULL) { + memcpy(ptr + destOffset, sourceArray + srcOffset, numelements*sizeof(TyHeapCell)); + } + } + + void FSHeap::copyFromArray(char sourceArray[], size_t srcOffset, TyHeapCell tyCell, size_t destOffset, size_t numelements) { + char * ptr = const_cast<char*>(get8BitArray(tyCell)); + if(ptr!=NULL) { + memcpy(ptr + destOffset, sourceArray + srcOffset, numelements); + } + } + + void FSHeap::copyFromArray(short sourceArray[], size_t srcOffset, TyHeapCell tyCell, size_t destOffset, size_t numelements) { + short * ptr = const_cast<short*>(get16BitArray(tyCell)); + if(ptr!=NULL) { + memcpy(ptr + destOffset, sourceArray + srcOffset, numelements * sizeof(short)); + } + } + + void FSHeap::copyFromArray(INT64 sourceArray[], size_t srcOffset, TyHeapCell tyCell, size_t destOffset, size_t numelements) { + INT64 * ptr = const_cast<INT64*>(get64BitArray(tyCell)); + if(ptr!=NULL) { + memcpy(ptr + destOffset, sourceArray + srcOffset, numelements * sizeof(INT64)); + } + } + + void FSHeap::copyToArray(size_t srcOffset, TyHeapCell tyCell, char destArray[], size_t destOffset, size_t numelements) { + char * ptr = const_cast<char*>(get8BitArray(tyCell)); + if(ptr!=NULL) { + memcpy(destArray + destOffset, ptr + srcOffset, numelements); + } + } + + void FSHeap::copyToArray(size_t srcOffset, TyHeapCell tyCell, TyHeapCell destArray[], size_t destOffset, size_t numelements) { + TyHeapCell * ptr = const_cast<TyHeapCell*>(getCArrayFromFS(tyCell)); + if(ptr!=NULL) { + memcpy(destArray + destOffset, ptr + srcOffset, numelements*sizeof(TyHeapCell) ); + } + } + + void FSHeap::copyToArray(size_t srcOffset, TyHeapCell tyCell, short destArray[], size_t destOffset, size_t numelements) { + short * ptr = const_cast<short*>(get16BitArray(tyCell)); + if(ptr!=NULL) { + memcpy(destArray + destOffset, ptr + srcOffset, numelements*sizeof(short) ); + } + } + + void FSHeap::copyToArray(size_t srcOffset, TyHeapCell tyCell, INT64 destArray[], size_t destOffset, size_t numelements) { + INT64 * ptr = const_cast<INT64*>(get64BitArray(tyCell)); + if(ptr!=NULL) { + memcpy(destArray + destOffset, ptr + srcOffset, numelements*sizeof(INT64) ); + } + } /*@}*/ @@ -1014,8 +1071,6 @@ namespace uima { return d; } - - } } Modified: uima/uimacpp/trunk/src/test/src/test_primitivetypes.cpp URL: http://svn.apache.org/viewvc/uima/uimacpp/trunk/src/test/src/test_primitivetypes.cpp?rev=1221237&r1=1221236&r2=1221237&view=diff ============================================================================== --- uima/uimacpp/trunk/src/test/src/test_primitivetypes.cpp (original) +++ uima/uimacpp/trunk/src/test/src/test_primitivetypes.cpp Tue Dec 20 13:00:06 2011 @@ -67,10 +67,10 @@ char chars[] = { }; -int shorts[] = { +short shorts[] = { 10,20,30,40,50 }; -int longs[] = { +INT64 longs[] = { 10000,20000,30000,40000,50000 }; double doubles[] = { @@ -89,7 +89,7 @@ int end = 5; char * viewName = "EnglishDocument"; #define BOOLEAN_ARRAY_SIZE 20 -void createExampleFS(CAS & cas) { +void createExampleFS(CAS & cas, bool copyarrays) { Type testType = cas.getTypeSystem().getType("test.primitives.Example"); Feature intF = testType.getFeatureByBaseName("intFeature"); @@ -143,44 +143,76 @@ void createExampleFS(CAS & cas) { } IntArrayFS intArrayFS = cas.createIntArrayFS(NUMBEROF(ints)); - for (size_t i=0; i< NUMBEROF(ints); ++i) { - intArrayFS.set(i, ints[i]); + if (copyarrays) { + intArrayFS.copyFromArray(ints,0,NUMBEROF(ints)-1,0); + } else { + for (size_t i=0; i< NUMBEROF(ints); ++i) { + intArrayFS.set(i, ints[i]); + } } - FloatListFS floatListFS = cas.createFloatListFS(); for (size_t i=0;i < NUMBEROF(floats); i++) { floatListFS.addLast(floats[i]); } FloatArrayFS floatArrayFS = cas.createFloatArrayFS(NUMBEROF(floats)); - for (size_t i=0; i< NUMBEROF(floats); ++i) { - floatArrayFS.set(i, floats[i]); + if (copyarrays) { + floatArrayFS.copyFromArray(floats,0,NUMBEROF(floats)-1,0); + } else { + for (size_t i=0; i< NUMBEROF(floats); ++i) { + floatArrayFS.set(i, floats[i]); + } } ByteArrayFS byteArrayFS = cas.createByteArrayFS(NUMBEROF(chars)); - for (size_t i=0; i< NUMBEROF(chars); ++i) { - byteArrayFS.set(i, chars[i]); + if (copyarrays) { + byteArrayFS.copyFromArray(chars,0,NUMBEROF(chars)-1,0); + } else { + for (size_t i=0; i< NUMBEROF(chars); ++i) { + byteArrayFS.set(i, chars[i]); + } } BooleanArrayFS boolArrayFS = cas.createBooleanArrayFS(BOOLEAN_ARRAY_SIZE); - for (int i=0; i<20; i++) { - boolArrayFS.set(i,val=!val); + bool bools[BOOLEAN_ARRAY_SIZE]; + for (int i=0; i<BOOLEAN_ARRAY_SIZE; i++) { + val = !val; + bools[i] = val; + } + if (copyarrays) { + boolArrayFS.copyFromArray(bools,0,NUMBEROF(bools)-1,0); + } else { + for (int i=0; i<BOOLEAN_ARRAY_SIZE; i++) { + boolArrayFS.set(i,bools[i]); + } } ShortArrayFS shortArrayFS = cas.createShortArrayFS(NUMBEROF(shorts)); - for (size_t i=0; i< NUMBEROF(shorts); ++i) { - shortArrayFS.set(i, shorts[i]); + if (copyarrays) { + shortArrayFS.copyFromArray(shorts,0,NUMBEROF(shorts)-1,0); + } else { + for (size_t i=0; i< NUMBEROF(shorts); ++i) { + shortArrayFS.set(i, shorts[i]); + } } LongArrayFS longArrayFS = cas.createLongArrayFS(NUMBEROF(longs)); - for (size_t i=0; i< NUMBEROF(longs); ++i) { - longArrayFS.set(i, longs[i]); + if (copyarrays) { + longArrayFS.copyFromArray(longs,0,NUMBEROF(longs)-1,0); + } else { + for (size_t i=0; i< NUMBEROF(longs); ++i) { + longArrayFS.set(i, longs[i]); + } } DoubleArrayFS doubleArrayFS = cas.createDoubleArrayFS(NUMBEROF(doubles)); - for (size_t i=0; i< NUMBEROF(doubles); ++i) { - doubleArrayFS.set(i, doubles[i]); + if (copyarrays) { + doubleArrayFS.copyFromArray(doubles,0,NUMBEROF(doubles)-1,0); + } else { + for (size_t i=0; i< NUMBEROF(doubles); ++i) { + doubleArrayFS.set(i, doubles[i]); + } } Type annot = cas.getTypeSystem().getType(CAS::TYPE_NAME_ANNOTATION); @@ -222,8 +254,11 @@ void createExampleFS(CAS & cas) { fs.setFeatureValue(stringListF, stringListFS); } +void createExampleFS(CAS & cas) { + createExampleFS(cas, false); +} -void validateFS(CAS & cas) { +void validateFS(CAS & cas, bool checkcopytoarray) { Type testType = cas.getTypeSystem().getType("test.primitives.Example"); @@ -290,6 +325,14 @@ void validateFS(CAS & cas) { for (size_t i=0; i< NUMBEROF(ints); ++i) { ASSERT_OR_THROWEXCEPTION(intArrayFS.get(i)==ints[i]); } + if (checkcopytoarray) { //copy only part of int array + int * destArray = new int[intArrayFS.size()]; + intArrayFS.copyToArray(2,intArrayFS.size()-1,destArray,0); + for (size_t i=0;i < intArrayFS.size()-2; i++ ) { + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==ints[i+2]); + } + delete destArray; + } FloatListFS floatListFS = fs.getFloatListFSValue(floatListF); for (num=0; num< NUMBEROF(floats); num++) { @@ -303,12 +346,28 @@ void validateFS(CAS & cas) { for (size_t i=0; i< NUMBEROF(floats); ++i) { ASSERT_OR_THROWEXCEPTION(floatArrayFS.get(i)==floats[i]); } + if (checkcopytoarray) { + float * destArray = new float[floatArrayFS.size()]; + floatArrayFS.copyToArray(0,floatArrayFS.size()-1,destArray,0); + for (size_t i=0;i < floatArrayFS.size(); i++ ) { + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==floats[i]); + } + delete destArray; + } ByteArrayFS byteArrayFS = fs.getByteArrayFSValue(byteArrayF); ASSERT_OR_THROWEXCEPTION(NUMBEROF(chars)==byteArrayFS.size()); for (size_t i=0; i< NUMBEROF(chars); ++i) { ASSERT_OR_THROWEXCEPTION(byteArrayFS.get(i)==chars[i]); } + if (checkcopytoarray) { + char * destArray = new char[byteArrayFS.size()]; + byteArrayFS.copyToArray(0,byteArrayFS.size()-1,destArray,0); + for (size_t i=0;i < byteArrayFS.size(); i++ ) { + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==chars[i]); + } + delete destArray; + } BooleanArrayFS boolArrayFS = fs.getBooleanArrayFSValue(booleanArrayF); ASSERT_OR_THROWEXCEPTION(BOOLEAN_ARRAY_SIZE==boolArrayFS.size()); @@ -316,24 +375,57 @@ void validateFS(CAS & cas) { val = !val; ASSERT_OR_THROWEXCEPTION(boolArrayFS.get(i)==val); } + if (checkcopytoarray) { + bool * destArray = new bool[boolArrayFS.size()]; + boolArrayFS.copyToArray(0,boolArrayFS.size()-1,destArray,0); + for (size_t i=0;i < boolArrayFS.size(); i++ ) { + val = !val; + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==val); + } + delete destArray; + } ShortArrayFS shortArrayFS = fs.getShortArrayFSValue(shortArrayF); ASSERT_OR_THROWEXCEPTION(NUMBEROF(shorts)==shortArrayFS.size()); for (size_t i=0; i< NUMBEROF(shorts); ++i) { ASSERT_OR_THROWEXCEPTION(shortArrayFS.get(i)==shorts[i]); } + if (checkcopytoarray) { + short * destArray = new short[shortArrayFS.size()]; + shortArrayFS.copyToArray(0,shortArrayFS.size()-1,destArray,0); + for (size_t i=0;i < shortArrayFS.size(); i++ ) { + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==shorts[i]); + } + delete destArray; + } LongArrayFS longArrayFS = fs.getLongArrayFSValue(longArrayF); ASSERT_OR_THROWEXCEPTION(NUMBEROF(longs)==longArrayFS.size()); for (size_t i=0; i< NUMBEROF(longs); ++i) { ASSERT_OR_THROWEXCEPTION(longArrayFS.get(i)==longs[i]); } + if (checkcopytoarray) { + INT64 * destArray = new INT64[longArrayFS.size()]; + longArrayFS.copyToArray(0,longArrayFS.size()-1,destArray,0); + for (size_t i=0;i < longArrayFS.size(); i++ ) { + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==longs[i]); + } + delete destArray; + } DoubleArrayFS doubleArrayFS = fs.getDoubleArrayFSValue(doubleArrayF); ASSERT_OR_THROWEXCEPTION(NUMBEROF(doubles)==doubleArrayFS.size()); for (size_t i=0; i< NUMBEROF(doubles); ++i) { ASSERT_OR_THROWEXCEPTION(doubleArrayFS.get(i) == doubles[i]); } + if (checkcopytoarray) { + double * destArray = new double[doubleArrayFS.size()]; + doubleArrayFS.copyToArray(0,doubleArrayFS.size()-1,destArray,0); + for (size_t i=0;i < doubleArrayFS.size(); i++ ) { + ASSERT_OR_THROWEXCEPTION( *(destArray+i)==doubles[i]); + } + delete destArray; + } FeatureStructure listFS = fs.getFSValue(fsListF); num=0; @@ -364,8 +456,34 @@ void validateFS(CAS & cas) { ASSERT_OR_THROWEXCEPTION(fs.getDoubleValue(doubleF)==doubles[0]); } +void validateFS(CAS & cas) { + validateFS(cas,false); +} + +void copyArrayExample(CAS & cas) { + Type testType = cas.getTypeSystem().getType("test.primitives.Example"); + Feature intArrayF = testType.getFeatureByBaseName("intArrayFeature"); + Feature floatArrayF = testType.getFeatureByBaseName("floatArrayFeature"); + Feature stringArrayF = testType.getFeatureByBaseName("stringArrayFeature"); + Feature booleanArrayF = testType.getFeatureByBaseName("boolArrayFeature"); + Feature byteArrayF = testType.getFeatureByBaseName("byteArrayFeature"); + Feature shortArrayF = testType.getFeatureByBaseName("shortArrayFeature"); + Feature longArrayF = testType.getFeatureByBaseName("longArrayFeature"); + Feature doubleArrayF = testType.getFeatureByBaseName("doubleArrayFeature"); + + //get index repository + FSIndexRepository & indexRep = cas.getIndexRepository(); + // Create a view + CAS * englishView = cas.createView(viewName); + // Set the document text + englishView->setDocumentText(ustr); + // create an FS of exampleType and index it + AnnotationFS fs = englishView->createAnnotation(testType, begin, end); + englishView->getIndexRepository().addFS(fs); + +} @@ -507,12 +625,23 @@ int main(int argc, char * argv[]) /* static TypeSystem *ts = Framework::createTypeSystemFromXMLBuffer(config, errorInfo ); CAS* cas = Framework::createCAS(*ts, errorInfo); ASSERT_OR_THROWEXCEPTION( EXISTS(cas) ); - + + LOG("UIMATEST_PRIMITIVETYPES test copyToArray "); + createExampleFS(*cas,false); + validateFS(*cas, true); + cas->reset(); + LOG("UIMATEST_PRIMITIVETYPES test copyToArray "); + createExampleFS(*cas,true); + validateFS(*cas, false); + cas->reset(); + + /* add a FS */ LOG("UIMATEST_PRIMITIVETYPES create a FS"); createExampleFS(*cas); validateFS(*cas); + /* test xcas serialization */ CAS* trgCas = Framework::createCAS(*ts, errorInfo); LOG("UIMATEST_PRIMITIVETYPES test XCAS serialization"); @@ -563,6 +692,15 @@ int main(int argc, char * argv[]) /* //LOG("deserialize data"); deserializer.deserializeData(serializedCas, *trgCas); validateFS(*trgCas); + + + /* test copyToArray and copyFromArray */ + LOG("UIMATEST_PRIMITIVETYPES copyToArray and copyFromArray"); + trgCas->reset(); + + + + delete ts; delete cas; delete trgCas;