You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@uima.apache.org by bh...@apache.org on 2011/12/20 14:00:07 UTC
svn commit: r1221237 - in /uima/uimacpp/trunk/src: cas/arrayfs.cpp
cas/uima/lowlevel_fsheap.hpp test/src/test_primitivetypes.cpp
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;