| |
| /** @name sofastream.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: This file contains class {\tt SofaDataSteram}. |
| |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| -------------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Interface dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| //#define DEBUG_VERBOSE |
| |
| #include "uima/pragmas.hpp" //must be included first to disable warnings |
| #include "uima/err_ids.h" |
| #include "uima/msg.h" |
| #include "uima/assertmsg.h" |
| #include "uima/trace.hpp" |
| #include "uima/resmgr.hpp" |
| #include "uima/sofastream.hpp" |
| #include "uima/lowlevel_fsheap.hpp" |
| #include "uima/arrayfs.hpp" |
| #include "uima/casexception.hpp" |
| #include "uima/endian.h" |
| #include "uima/sofastreamhandler.hpp" |
| namespace uima { |
| |
| |
| |
| // ----------------------------------------------------------- */ |
| // RemoteSofaDataStream implementation */ |
| // ----------------------------------------------------------- */ |
| //Constructor |
| RemoteSofaDataStream::RemoteSofaDataStream(SofaFS& aSofaFS) : iv_psofafs(NULL), |
| iv_pHandler(NULL), iv_pHandlerDll(NULL) { |
| iv_psofafs = (SofaFS*) new FeatureStructure(aSofaFS.iv_tyFS,aSofaFS.getCAS()); |
| assert(iv_psofafs->isValid()); |
| assert(iv_psofafs->getType().getName().compare( UnicodeStringRef(CAS::TYPE_NAME_SOFA)) == 0 ); |
| } |
| |
| //Destructor |
| RemoteSofaDataStream::~RemoteSofaDataStream() { |
| if (iv_pHandler != NULL) { |
| iv_pHandler->closeStream(); |
| delete iv_pHandler; |
| iv_pHandler = NULL; |
| } |
| if (iv_pHandlerDll != NULL) { |
| delete iv_pHandlerDll; |
| iv_pHandlerDll=NULL; |
| } |
| if (iv_psofafs != NULL) { |
| delete iv_psofafs; |
| } |
| } |
| |
| |
| |
| //open - minbufsize optional |
| int RemoteSofaDataStream::open(size_t minbufsize) { |
| std::string sofauri; |
| std::string urischeme; |
| util::Filename const * pDllFile=NULL; |
| |
| //get the sofa uri as UTF-8 string |
| iv_psofafs->getSofaURI().extract(0, |
| iv_psofafs->getSofaURI().length(), |
| sofauri, |
| CCSID::getDefaultSBCSInputCCSID() ); |
| //get the uri scheme |
| int32_t pos = sofauri.find(":"); |
| if (pos != -1) { |
| //get the uri scheme |
| urischeme = sofauri.substr(0,pos); |
| } else { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_INVALID_SOFAURI); |
| errMsg.addParam(sofauri); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| //look up sofa stream handler for uri scheme |
| if (urischeme.size() > 0) { |
| pDllFile = uima::ResourceManager::getInstance().getStreamHandlerForURIScheme(urischeme); |
| if (pDllFile == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SCHEMEHANDLER_NOT_REGISTERED); |
| errMsg.addParam(urischeme); |
| errMsg.addParam(sofauri); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| } else { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_INVALID_SOFAURI); |
| errMsg.addParam(sofauri); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| //load the handler |
| iv_pHandlerDll = new util::DllProcLoaderFile(*pDllFile); |
| //assert(EXISTS(iv_pHandlerDll)); |
| if (iv_pHandlerDll == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SCHEMEHANDLER_LOAD); |
| errMsg.addParam(pDllFile->getName()); |
| errMsg.addParam(sofauri); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| uima::TyMakeStreamHandler procMaker = (TyMakeStreamHandler) iv_pHandlerDll->getProcedure(UIMA_SOFASTREAM_MAKE_HANDLER); |
| assert(EXISTS(procMaker)); |
| if (NOTEXISTS(procMaker)) { |
| ResourceManager::getInstance().getLogger().logError("RemoteSofaDataStream::open() Could not get procedure makeHandler() "); |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SCHEMEHANDLER_GETPROC); |
| errMsg.addParam(pDllFile->getName()); |
| errMsg.addParam(sofauri); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| /* first we need to create the handler */ |
| iv_pHandler = (procMaker) (); |
| |
| if (NOTEXISTS(iv_pHandler)) { |
| ResourceManager::getInstance().getLogger().logError("RemoteSofaDataStream::open() Could not instantiate stream handler. "); |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SCHEMEHANDLER_GETPROC); |
| errMsg.addParam(pDllFile->getName()); |
| errMsg.addParam(sofauri); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| /* open the stream */ |
| if (minbufsize > 0) { |
| iv_pHandler->openStream(sofauri.data(), minbufsize); |
| } else { |
| iv_pHandler->openStream(sofauri.data()); |
| } |
| |
| return 0; |
| } |
| |
| // Have a lot of near-identical error code ... Could we make it simpler with a single error routine? BLL |
| |
| //getTotalStreamSize |
| INT64 RemoteSofaDataStream::getTotalStreamSizeInBytes() { |
| if (iv_pHandler == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SOFADATASTREAM_NOTOPEN); |
| errMsg.addParam("getTotalStreamSize"); |
| errMsg.addParam(iv_psofafs->getSofaURI()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| return (iv_pHandler->getTotalStreamSize()); |
| } |
| |
| //howManyBytesAvailable |
| INT64 RemoteSofaDataStream::howManyBytesAvailable() { |
| if (iv_pHandler == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SOFADATASTREAM_NOTOPEN); |
| errMsg.addParam("HowManyBytesAvailable"); |
| errMsg.addParam(iv_psofafs->getSofaURI()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| return ( iv_pHandler->howManyAvailable()); |
| } |
| |
| //read |
| int RemoteSofaDataStream::read( void * pbuffer, int elementSize, size_t numElements) { |
| |
| if (iv_pHandler == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SOFADATASTREAM_NOTOPEN); |
| errMsg.addParam("read"); |
| errMsg.addParam(iv_psofafs->getSofaURI()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| INT64 numbytesread = elementSize*numElements; |
| |
| //read bytes |
| numbytesread = iv_pHandler->getNext(numbytesread,pbuffer); |
| |
| //swap bytes if needed (data read is assumed to be BE) |
| if (numbytesread > 0) { |
| if ( elementSize==2 || elementSize==4 || elementSize == 8) { |
| // Convert BE data to host byte order |
| UIMA_HIBYTEFIRST(pbuffer, elementSize, numbytesread/elementSize); |
| return numbytesread/elementSize; // return number of elements read |
| } |
| } |
| return numbytesread; // assume elementSize = 1 |
| } |
| |
| //seek |
| int RemoteSofaDataStream::seek(INT64 offset, int origin) { |
| if (iv_pHandler == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SOFADATASTREAM_NOTOPEN); |
| errMsg.addParam("seek"); |
| errMsg.addParam(iv_psofafs->getSofaURI()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| return (iv_pHandler->seek(offset,origin)); |
| } |
| |
| //close |
| void RemoteSofaDataStream::close() { |
| if (iv_pHandler != NULL) { |
| iv_pHandler->closeStream(); |
| } |
| } |
| |
| //getDataPointer |
| const TySofaDataPointer RemoteSofaDataStream::getDataPointer() { |
| |
| if (iv_pHandler == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SOFADATASTREAM_NOTOPEN); |
| errMsg.addParam("getDataPointer"); |
| errMsg.addParam(iv_psofafs->getSofaURI()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| return (iv_pHandler->getDataPointer()); |
| |
| } |
| |
| // ----------------------------------------------------------- */ |
| // LocalSofaDataStream implementation */ |
| // ----------------------------------------------------------- */ |
| |
| //Constructor |
| LocalSofaDataStream::LocalSofaDataStream(SofaFS& aSofaFS) : iv_psofafs(NULL), |
| iv_psofadata(NULL), iv_pstringsofadata(NULL), iv_size(0), |
| iv_isstring(false), iv_isintarray(false), |
| iv_isfloatarray(false), iv_isbooleanarray(false), |
| iv_isbytearray(false),iv_isshortarray(false), |
| iv_islongarray(false),iv_isdoublearray(false), |
| iv_curpos(0) { |
| iv_psofafs = (SofaFS*) new FeatureStructure(aSofaFS.iv_tyFS,aSofaFS.getCAS()); |
| assert(iv_psofafs->isValid()); |
| assert(iv_psofafs->getType().getName().compare( UnicodeStringRef(CAS::TYPE_NAME_SOFA)) == 0 ); |
| } |
| |
| //Destructor |
| LocalSofaDataStream::~LocalSofaDataStream() { |
| close(); |
| if (iv_psofafs != NULL) |
| delete iv_psofafs; |
| } |
| |
| //open - minbufsize ignored |
| int LocalSofaDataStream::open(size_t minbufsize) { |
| |
| Type type = iv_psofafs->getType(); |
| Feature stringfeat = type.getFeatureByBaseName(CAS::FEATURE_BASE_NAME_SOFASTRING); |
| Feature arrayfeat = type.getFeatureByBaseName(CAS::FEATURE_BASE_NAME_SOFAARRAY); |
| |
| iv_curpos=0; |
| if ( !iv_psofafs->isUntouchedFSValue(stringfeat) ) { //local sofa - data in string |
| //convert string to UTF-8 |
| UErrorCode errorcode = U_ZERO_ERROR ; |
| iv_size=0; |
| int32_t len; |
| iv_psofadata = u_strToUTF8(NULL, 0, |
| &len, |
| iv_psofafs->getStringValue(stringfeat).getBuffer(), |
| iv_psofafs->getStringValue(stringfeat).length(), |
| &errorcode); |
| if (!U_SUCCESS(errorcode) && errorcode != U_BUFFER_OVERFLOW_ERROR ) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_UNSUPPORTED_TYPE); |
| errMsg.addParam(stringfeat.getName()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| iv_pstringsofadata = new char[len]; |
| iv_size = len; |
| errorcode = U_ZERO_ERROR ; |
| iv_psofadata = u_strToUTF8(iv_pstringsofadata, iv_size, |
| &len, |
| iv_psofafs->getStringValue(stringfeat).getBuffer(), |
| iv_psofafs->getStringValue(stringfeat).length(), |
| &errorcode); |
| if (!U_SUCCESS(errorcode) ) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_UNSUPPORTED_TYPE); |
| errMsg.addParam(stringfeat.getName()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| iv_isstring=true; |
| } else if ( !iv_psofafs->isUntouchedFSValue(arrayfeat) ) { //local sofa - data in fs array |
| |
| FeatureStructure arrayFS = iv_psofafs->getFSValue(arrayfeat); |
| Type rangeType = arrayFS.getType(); |
| UnicodeStringRef rangeTypeName = rangeType.getName(); |
| |
| if (rangeTypeName.compare(CAS::TYPE_NAME_INTEGER_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->getCArrayFromFS(arrayFS.iv_tyFS); |
| iv_size = iv_psofafs->getIntArrayFSValue(arrayfeat).size()*sizeof(int); |
| iv_isintarray = true; |
| } else if (rangeTypeName.compare( CAS::TYPE_NAME_FLOAT_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->getCArrayFromFS(arrayFS.iv_tyFS); |
| iv_size= iv_psofafs->getFloatArrayFSValue(arrayfeat).size()*sizeof(float); |
| iv_isfloatarray = true; |
| } else if (rangeTypeName.compare( CAS::TYPE_NAME_BOOLEAN_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->get8BitArray(arrayFS.iv_tyFS); |
| iv_size= iv_psofafs->getBooleanArrayFSValue(arrayfeat).size()*sizeof(char); |
| iv_isbooleanarray = true; |
| } else if (rangeTypeName.compare( CAS::TYPE_NAME_BYTE_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->get8BitArray(arrayFS.iv_tyFS); |
| iv_size= iv_psofafs->getByteArrayFSValue(arrayfeat).size()*sizeof(char); |
| iv_isbytearray = true; |
| } else if (rangeTypeName.compare( CAS::TYPE_NAME_SHORT_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->get16BitArray(arrayFS.iv_tyFS); |
| iv_size= iv_psofafs->getShortArrayFSValue(arrayfeat).size()*sizeof(short); |
| iv_isshortarray = true; |
| } else if (rangeTypeName.compare( CAS::TYPE_NAME_LONG_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->get64BitArray(arrayFS.iv_tyFS); |
| iv_size= iv_psofafs->getLongArrayFSValue(arrayfeat).size()*sizeof(INT64); |
| iv_islongarray = true; |
| } else if (rangeTypeName.compare( CAS::TYPE_NAME_DOUBLE_ARRAY) ==0) { |
| iv_psofadata = (char*) iv_psofafs->getCAS().getHeap()->get64BitArray(arrayFS.iv_tyFS); |
| iv_size= iv_psofafs->getDoubleArrayFSValue(arrayfeat).size()*sizeof(INT64); |
| iv_isdoublearray = true; |
| } else { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_UNSUPPORTED_TYPE); |
| errMsg.addParam(rangeTypeName); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| } else { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_NOTSET); |
| errMsg.addParam(type.getName()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| return 0; |
| } |
| |
| //getTotalStreamSize |
| INT64 LocalSofaDataStream::getTotalStreamSizeInBytes() { |
| if (iv_size==0) { |
| return SOFASTREAMHANDLER_EOF; |
| } else return iv_size; |
| } |
| |
| //howManyBytesAvailable |
| INT64 LocalSofaDataStream::howManyBytesAvailable() { |
| return (getTotalStreamSizeInBytes()-iv_curpos); |
| } |
| |
| |
| //read |
| int LocalSofaDataStream::read( void * pbuffer, int elementSize, size_t numElements) { |
| //check valid sofa data |
| if (iv_psofadata == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_NOTSET); |
| errMsg.addParam(iv_psofafs->getType().getName()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| //check for eof |
| if (iv_curpos == iv_size) { |
| return SOFASTREAMHANDLER_EOF; |
| } |
| |
| //validate element size vis-a-vis datatype of sofa data |
| if (iv_isstring && elementSize != 1) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_ELEMENTSIZE); |
| errMsg.addParam(elementSize); |
| errMsg.addParam(CAS::TYPE_NAME_STRING); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } else if (iv_isintarray && elementSize != sizeof(int)) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_ELEMENTSIZE); |
| errMsg.addParam(elementSize); |
| errMsg.addParam(CAS::TYPE_NAME_INTEGER_ARRAY); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } else if (iv_isfloatarray && elementSize != sizeof(float) ) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_ELEMENTSIZE); |
| errMsg.addParam(elementSize); |
| errMsg.addParam(CAS::TYPE_NAME_FLOAT_ARRAY); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| INT64 numbytesread=elementSize*numElements; |
| if (numbytesread > howManyBytesAvailable() ) { |
| numbytesread= howManyBytesAvailable(); |
| } |
| |
| //read bytes |
| memcpy(pbuffer,iv_psofadata+iv_curpos,numbytesread); |
| |
| //move current read position |
| iv_curpos += numbytesread; |
| |
| return numbytesread; |
| } |
| |
| //seek |
| int LocalSofaDataStream::seek(INT64 offset, int origin) { |
| if (iv_psofadata == NULL) { |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_LOCAL_SOFADATA_NOTSET); |
| errMsg.addParam(iv_psofafs->getType().getName()); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| |
| switch (origin) { |
| case SEEK_SET: |
| iv_curpos = offset; |
| break ; |
| case SEEK_CUR: |
| iv_curpos += offset; |
| break ; |
| case SEEK_END: |
| iv_curpos = getTotalStreamSizeInBytes() - offset; |
| break ; |
| default: |
| ErrorMessage errMsg = ErrorMessage(UIMA_MSG_ID_EXC_SOFADATASTREAM_INVALID_SEEK_ORIGIN); |
| errMsg.addParam(origin); |
| UIMA_EXC_THROW_NEW(SofaDataStreamException, |
| UIMA_ERR_SOFADATASTREAM, |
| errMsg, |
| UIMA_MSG_ID_EXCON_SOFADATASTREAM, |
| ErrorInfo::unrecoverable); |
| } |
| return 0; |
| } |
| |
| //close |
| void LocalSofaDataStream::close() { |
| if (iv_pstringsofadata != NULL) |
| delete[] iv_pstringsofadata; |
| iv_pstringsofadata = NULL; |
| iv_curpos=0; |
| iv_psofadata = NULL; |
| iv_size=0; |
| iv_isstring=false; |
| iv_isintarray=false; |
| iv_isfloatarray=false; |
| } |
| |
| //getDataPointer |
| const TySofaDataPointer LocalSofaDataStream::getDataPointer() { |
| TySofaDataPointer dataptr=NULL; |
| if (iv_psofadata != NULL) { |
| dataptr = (TySofaDataPointer) iv_psofadata; |
| } |
| return dataptr; |
| } |
| |
| |
| } //namespace uima |
