void CASDeserializer::deserializeData(uima::internal::SerializedCAS const & crSerializedCAS,
uima::CAS & rCAS) {
uima::CAS * baseCAS = rCAS.getBaseCas();
baseCAS->reset();
deserializeHeapsAndStringTable( crSerializedCAS, *baseCAS );
deserializeIndexedFSs(CONST_CAST(vector<SerializedCAS::TyNum>&,crSerializedCAS.iv_vecIndexedFSs), *baseCAS);
// deserializeDocument(crSerializedCAS, rCAS); // do this last because only here is the document annotation created
}
// for blob deserialization
void CASDeserializer::deserializeBlob(void * buffer, uima::CAS & rCAS) {
vector<SerializedCAS::TyNum> iv_vecIndexedFSs;
// check blob "key" and version
int* intPtr = (int*) buffer;
// Check if blob needs byteswap
#if defined(WORDS_BIGENDIAN)
char key[] = "UIMA";
char yek[] = "AMIU";
#else
char key[] = "AMIU";
char yek[] = "UIMA";
#endif
if (intPtr[0] == ((int*)yek)[0]) {
swapBlob(buffer);
}
CHECK(intPtr[0] == ((int*)key)[0]);
CHECK(intPtr[1] == 1);
// get a heap of references
uima::internal::CASImpl & crCASImpl = uima::internal::CASImpl::promoteCAS(rCAS);
uima::lowlevel::FSHeap & crHeap = crCASImpl.getHeap();
uima::lowlevel::FSHeap::TyFSHeap & tyTempHeap = crHeap.iv_clTemporaryHeap;
uima::lowlevel::FSHeap::TyStringHeap & tyStringHeap = crHeap.iv_clTemporaryStringHeap;
uima::lowlevel::FSHeap::TyStringRefHeap & tyStringRefHeap = crHeap.iv_clTemporaryStringRefHeap;
uima::lowlevel::FSHeap::Ty8BitHeap & ty8BitHeap = crHeap.iv_clTemporary8BitHeap;
uima::lowlevel::FSHeap::Ty16BitHeap & ty16BitHeap = crHeap.iv_clTemporary16BitHeap;
uima::lowlevel::FSHeap::Ty64BitHeap & ty64BitHeap = crHeap.iv_clTemporary64BitHeap;
// deserialize FSHeap
tyTempHeap.reset();
size_t uiFSHeapLength = intPtr[2];
if (uiFSHeapLength > 1) {
CHECK(intPtr[3] == 0);
tyTempHeap.increaseHeap(uiFSHeapLength-1);
memcpy(tyTempHeap.getHeapStart(), intPtr+3, 4*uiFSHeapLength);
}
intPtr += 3 + uiFSHeapLength;
// deserialize StringTable
tyStringHeap.reset();
size_t uiStringHeapLength = intPtr[0];
size_t uialignedStrLen = 2 * ((uiStringHeapLength + 1)/2);
if (uiStringHeapLength > 1) {
CHECK(((short*)intPtr)[2] == 0); // check the first short after the length
tyStringHeap.increaseHeap(uiStringHeapLength-1);
memcpy(tyStringHeap.getHeapStart(), intPtr+1, 2*uiStringHeapLength);
}
intPtr += 1 + uialignedStrLen/2;
// deserialize StringRef
tyStringRefHeap.reset();
size_t uiRefHeapLength = intPtr[0];
if (uiRefHeapLength > 1) {
CHECK(intPtr[1] == 0);
tyStringRefHeap.increaseHeap(uiRefHeapLength-1);
memcpy(tyStringRefHeap.getHeapStart(), intPtr+1, 4*uiRefHeapLength);
}
intPtr += 1 + uiRefHeapLength;
// create FS indexes
size_t uiIndexedFSLength = intPtr[0];
if (uiIndexedFSLength > 0) {
uima::CAS * baseCAS = rCAS.getBaseCas();
iv_vecIndexedFSs.resize(uiIndexedFSLength);
memcpy(&iv_vecIndexedFSs[0], intPtr+1, 4*uiIndexedFSLength);
deserializeIndexedFSs(iv_vecIndexedFSs, *baseCAS);
}
intPtr += 1 + uiIndexedFSLength;
//8bit heap
ty8BitHeap.reset();
size_t ui8BitHeapLength = intPtr[0];
size_t uialigned8BitHeapLen = 4 * ((ui8BitHeapLength + 3)/4);
if (ui8BitHeapLength > 1) {
//CHECK(((char*)intPtr)[1] == 0);
ty8BitHeap.increaseHeap(ui8BitHeapLength-1);
memcpy(ty8BitHeap.getHeapStart(), intPtr+1, ui8BitHeapLength);
}
intPtr += 1 + uialigned8BitHeapLen/4;
//16 bit heap
ty16BitHeap.reset();
size_t ui16BitHeapLength = intPtr[0];
size_t uialigned16BitHeapLen = 2 * ((ui16BitHeapLength + 1)/2);
if (ui16BitHeapLength > 1) {
//CHECK(((short*)intPtr)[2] == 0);
ty16BitHeap.increaseHeap(ui16BitHeapLength-1);
memcpy(ty16BitHeap.getHeapStart(), intPtr+1, 2*ui16BitHeapLength);
}
intPtr += 1 + uialigned16BitHeapLen/2;
//64 bit heap
ty64BitHeap.reset();
size_t ui64BitHeapLength = intPtr[0];
if (ui64BitHeapLength > 0) {
//CHECK(intPtr[1] == 0);
ty64BitHeap.increaseHeap(ui64BitHeapLength-1);
memcpy(ty64BitHeap.getHeapStart(), intPtr+1, 8*ui64BitHeapLength);
}
}
void CASDeserializer::deserializeIndexedFSs(vector<SerializedCAS::TyNum> & crIndexFSs,
uima::CAS & rCAS) {
uima::internal::CASImpl & rCASImpl = uima::internal::CASImpl::promoteCAS(rCAS);
uima::lowlevel::FSHeap & crHeap = rCASImpl.getHeap();
uima::lowlevel::IndexRepository * crIndexRep = &rCASImpl.getIndexRepository();
uima::lowlevel::FSHeap::TyFSHeap const & rTempFSHeap = crHeap.iv_clTemporaryHeap;
SerializedCAS::TyNum iMaxOffset = rTempFSHeap.getTopOfHeap();
vector<SerializedCAS::TyNum>::const_iterator cit, loopit;
vector<SerializedCAS::TyNum> perLoopIndexedFSs;
cit = crIndexFSs.begin();
int numViews = *cit++;
int loopSize = *cit;
crIndexRep->reset();
// deserialize base CAS
if (loopSize > 0) {
lastSegmentUsed = 0;
perLoopIndexedFSs.insert(perLoopIndexedFSs.end(), cit+1, cit+1+loopSize);
cit += loopSize + 1;
for (loopit = perLoopIndexedFSs.begin(); loopit != perLoopIndexedFSs.end(); ++loopit) {
assert( *loopit < iMaxOffset );
crIndexRep->add( *loopit );
}
}
// book keeping for all Sofas
rCAS.getBaseCas()->iv_sofaCount = 1; // reserve for initial view
FSIndex fsIdx = crIndexRep->getIndex(CAS::INDEXID_SOFA);
FSIterator fsIt = fsIdx.iterator();
while (fsIt.isValid()) {
SofaFS aSofa = (SofaFS) fsIt.get();
if ( 0 == aSofa.getSofaID().compare(UnicodeString(CAS::NAME_DEFAULT_SOFA)) ) {
rCAS.registerInitialSofa();
} else {
// only bump sofa count if not initial View
rCAS.bumpSofaCount();
}
rCAS.getView(aSofa)->registerView(aSofa);
fsIt.moveToNext();
}
for (int view = 1; view <= numViews; view++) {
// Check if sofa's index has anything in it
loopSize = *cit;
if (0 == loopSize) {
cit++;
continue;
}
CAS* tcas = rCAS.getViewBySofaNum(view);
uima::internal::CASImpl & crTCASImpl = uima::internal::CASImpl::promoteCAS(*tcas);
crIndexRep = &crTCASImpl.getIndexRepository();
crIndexRep->reset();
perLoopIndexedFSs.clear();
perLoopIndexedFSs.insert(perLoopIndexedFSs.end(), cit+1, cit+1+loopSize);
cit += loopSize + 1;
for (loopit = perLoopIndexedFSs.begin(); loopit != perLoopIndexedFSs.end(); ++loopit) {
assert( *loopit < iMaxOffset );
crIndexRep->add( *loopit );
}
tcas->pickupDocumentAnnotation();
}
}