// This method returns the data associated with a key. The key entry is deleted. The caller
// now owns the returned data (case of hashtable adopting the data).
// This function is called by transferElement so that the undeleted data can be transferred
// to a new key which will own that data.
template <class TVal> TVal* RefHashTableOf<TVal>::
orphanKey(const void* const key)
{
// Hash the key
TVal* retVal = 0;
unsigned int hashVal = fHash->getHashVal(key, fHashModulus);
if (hashVal > fHashModulus)
ThrowXML(RuntimeException, XMLExcepts::HshTbl_BadHashFromKey);
//
// Search the given bucket for this key. Keep up with the previous
// element so we can patch around it.
//
RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
RefHashTableBucketElem<TVal>* lastElem = 0;
while (curElem)
{
if (fHash->equals(key, curElem->fKey))
{
if (!lastElem)
{
// It was the first in the bucket
fBucketList[hashVal] = curElem->fNext;
}
else
{
// Patch around the current element
lastElem->fNext = curElem->fNext;
}
retVal = curElem->fData;
// Delete the current element
delete curElem;
break;
}
// Move both pointers upwards
lastElem = curElem;
curElem = curElem->fNext;
}
// We never found that key
if (!retVal)
ThrowXML(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists);
return retVal;
}
// ---------------------------------------------------------------------------
// ValueArrayOf: Miscellaneous methods
// ---------------------------------------------------------------------------
template <class TElem> void ValueArrayOf<TElem>::
resize(const unsigned int newSize)
{
if (newSize == fSize)
return;
if (newSize < fSize)
ThrowXML(IllegalArgumentException, XMLExcepts::Array_BadNewSize);
// Allocate the new array
TElem* newArray = new TElem[newSize];
// Copy the existing values
unsigned int index = 0;
for (; index < fSize; index++)
newArray[index] = fArray[index];
for (; index < newSize; index++)
newArray[index] = TElem(0);
// Delete the old array and udpate our members
delete [] fArray;
fArray = newArray;
fSize = newSize;
}
void
XMLMacCarbonFile::reset()
{
OSErr err = noErr;
if (!mFileValid)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotResetFile);
if (gHasHFSPlusAPIs)
err = FSSetForkPosition(mFileRefNum, fsFromStart, 0);
else
err = SetFPos(mFileRefNum, fsFromStart, 0);
if (err != noErr)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotResetFile);
}
template <class TElem> TElem* BaseRefVectorOf<TElem>::
orphanElementAt(const unsigned int orphanAt)
{
if (orphanAt >= fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
// Get the element we are going to orphan
TElem* retVal = fElemList[orphanAt];
// Optimize if its the last element
if (orphanAt == fCurCount-1)
{
fElemList[orphanAt] = 0;
fCurCount--;
return retVal;
}
// Copy down every element above orphan point
for (unsigned int index = orphanAt; index < fCurCount-1; index++)
fElemList[index] = fElemList[index+1];
// Keep unused elements zero for sanity's sake
fElemList[fCurCount-1] = 0;
// And bump down count
fCurCount--;
return retVal;
}
template <class TElem> void BaseRefVectorOf<TElem>::
removeElementAt(const unsigned int removeAt)
{
if (removeAt >= fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
if (fAdoptedElems)
delete fElemList[removeAt];
// Optimize if its the last element
if (removeAt == fCurCount-1)
{
fElemList[removeAt] = 0;
fCurCount--;
return;
}
// Copy down every element above remove point
for (unsigned int index = removeAt; index < fCurCount-1; index++)
fElemList[index] = fElemList[index+1];
// Keep unused elements zero for sanity's sake
fElemList[fCurCount-1] = 0;
// And bump down count
fCurCount--;
}
template <class TElem> TElem*
BaseRefVectorOf<TElem>::elementAt(const unsigned int getAt)
{
if (getAt >= fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
return fElemList[getAt];
}
template <class TElem> void ValueVectorOf<TElem>::
setElementAt(const TElem& toSet, const unsigned int setAt)
{
if (setAt >= fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
fElemList[setAt] = toSet;
}
template <class TElem> const TElem& ValueArrayOf<TElem>::
operator[](const unsigned int index) const
{
if (index >= fSize)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Array_BadIndex);
return fArray[index];
}
void
XMLMacCarbonFile::close()
{
OSErr err = noErr;
if (!mFileValid)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotCloseFile);
if (gHasHFSPlusAPIs)
err = FSCloseFork(mFileRefNum);
else
err = FSClose(mFileRefNum);
mFileValid = false;
if (err != noErr)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotCloseFile);
}
XERCES_CPP_NAMESPACE_BEGIN
URLAccessBinInputStream::URLAccessBinInputStream(const XMLURL& urlSource)
: mBytesProcessed(0),
mURLReference(NULL),
mBuffer(NULL),
mBufPos(NULL),
mBufAvailable(0)
{
OSStatus status = noErr;
// Get the full URL from the source
char* url = XMLString::transcode(urlSource.getURLText(), urlSource.getMemoryManager());
ArrayJanitor<char> janBuf(url, urlSource.getMemoryManager());
// Create a URL reference from the URL
status = URLNewReference(url, &mURLReference);
// Begin the transfer
if (status == noErr)
status = URLOpen(
mURLReference,
NULL, // FSSpec* (not reading to file)
0, // URLOpenFlags
NULL, // URLNotifyUPP
0, // URLEventMask
0); // userContext
// If we failed, we throw
switch (status)
{
case noErr:
break;
case kURLInvalidURLError:
ThrowXML(MalformedURLException, XMLExcepts::URL_MalformedURL);
break;
case kURLUnsupportedSchemeError:
ThrowXML(MalformedURLException, XMLExcepts::URL_UnsupportedProto);
break;
default:
ThrowXML1(NetAccessorException, XMLExcepts::NetAcc_ConnSocket, urlSource.getURLText());
break;
}
}
BinInputStream*
MacOSURLAccessCF::makeNew(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo/*=0*/)
{
if(httpInfo!=0 && httpInfo->fHTTPMethod!=XMLNetHTTPInfo::GET)
ThrowXML(NetAccessorException, XMLExcepts::NetAcc_UnsupportedMethod);
BinInputStream* result = new (urlSource.getMemoryManager()) URLAccessCFBinInputStream(urlSource);
return result;
}
void StdOutFormatTarget::writeChars(const XMLByte* const toWrite
, const XMLSize_t count
, XMLFormatter* const)
{
XMLSize_t written=fwrite(toWrite, sizeof(XMLByte), count, stdout);
if(written!=count)
ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotWriteToFile);
fflush(stdout);
}
TVal& SimpleValueHashTableOf<TVal, THasher>::get(const void* const key)
{
XMLSize_t hashVal;
ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
ThrowXML(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists);
return findIt->fData;
}
// ---------------------------------------------------------------------------
// SimpleValueHashTableOf: Getters
// ---------------------------------------------------------------------------
template <class TVal> TVal& SimpleValueHashTableOf<TVal>::get(const void* const key)
{
unsigned int hashVal;
ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
ThrowXML(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists);
return findIt->fData;
}
void SimpleValueHashTableOf<TVal, THasher>::
removeBucketElem(const void* const key, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHasher.getHashVal(key, fHashModulus);
if (hashVal > fHashModulus)
ThrowXML(RuntimeException, XMLExcepts::HshTbl_BadHashFromKey);
//
// Search the given bucket for this key. Keep up with the previous
// element so we can patch around it.
//
ValueHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
ValueHashTableBucketElem<TVal>* lastElem = 0;
while (curElem)
{
if (fHasher.equals(key, curElem->fKey))
{
if (!lastElem)
{
// It was the first in the bucket
fBucketList[hashVal] = curElem->fNext;
}
else
{
// Patch around the current element
lastElem->fNext = curElem->fNext;
}
// Delete the current element
delete curElem;
return;
}
// Move both pointers upwards
lastElem = curElem;
curElem = curElem->fNext;
}
// We never found that key
ThrowXML(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists);
}
template <class TElem> void
BaseRefVectorOf<TElem>::setElementAt(TElem* const toSet, const unsigned int setAt)
{
if (setAt >= fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
if (fAdoptedElems)
delete fElemList[setAt];
fElemList[setAt] = toSet;
}
template <class TVal> void SimpleValueHashTableOf<TVal>::initialize(const unsigned int modulus)
{
if (modulus == 0)
ThrowXML(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus);
// Allocate the bucket list and zero them
fBucketList = new ValueHashTableBucketElem<TVal>*[fHashModulus];
for (unsigned int index = 0; index < fHashModulus; index++)
fBucketList[index] = 0;
}
static void WriteUStrStdOut( const XMLCh* const toWrite)
{
char* tmpVal = XMLString::transcode(toWrite, XMLPlatformUtils::fgMemoryManager);
ArrayJanitor<char> janText(tmpVal, XMLPlatformUtils::fgMemoryManager);
if (fputs(tmpVal, stdout) == EOF)
{
ThrowXML(XMLPlatformUtilsException,
XMLExcepts::Strm_StdOutWriteFailure);
}
}
BinInputStream*
MacOSURLAccess::makeNew(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo/*=0*/)
{
if(httpInfo!=0 && httpInfo->fHTTPMethod!=XMLNetHTTPInfo::GET)
ThrowXML(NetAccessorException, XMLExcepts::NetAcc_UnsupportedMethod);
// We just go ahead and try to create a URLAccess stream
// from this source. That's the correct place to verify
// whether or not we can really handle this URL type...
// if it throws, well, it throws ;)
BinInputStream* result = new (urlSource.getMemoryManager()) URLAccessBinInputStream(urlSource);
return result;
}
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Local Methods
// ---------------------------------------------------------------------------
static void WriteCharStr( FILE* stream, const char* const toWrite)
{
if (fputs(toWrite, stream) == EOF)
{
ThrowXML(XMLPlatformUtilsException,
XMLExcepts::Strm_StdErrWriteFailure);
}
}
template <class TVal> TVal& ValueHashTableOfEnumerator<TVal>::nextElement()
{
// Make sure we have an element to return
if (!hasMoreElements())
ThrowXML(NoSuchElementException, XMLExcepts::Enum_NoMoreElements);
//
// Save the current element, then move up to the next one for the
// next time around.
//
ValueHashTableBucketElem<TVal>* saveElem = fCurElem;
findNext();
return saveElem->fData;
}
// ---------------------------------------------------------------------------
// ValueHashTableOfEnumerator: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TVal> ValueHashTableOfEnumerator<TVal>::
ValueHashTableOfEnumerator(SimpleValueHashTableOf<TVal>* const toEnum, const bool adopt)
: fAdopted(adopt), fCurElem(0), fCurHash((unsigned int)-1), fToEnum(toEnum)
{
if (!toEnum)
ThrowXML(NullPointerException, XMLExcepts::CPtr_PointerIsZero);
//
// Find the next available bucket element in the hash table. If it
// comes back zero, that just means the table is empty.
//
// Note that the -1 in the current hash tells it to start from the
// beginning.
//
findNext();
}
ValueHashTableBucketElem<TVal>* SimpleValueHashTableOf<TVal, THasher>::
findBucketElem(const void* const key, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHasher.getHashVal(key, fHashModulus);
if (hashVal > fHashModulus)
ThrowXML(RuntimeException, XMLExcepts::HshTbl_BadHashFromKey);
// Search that bucket for the key
ValueHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
while (curElem)
{
if (fHasher.equals(key, curElem->fKey))
return curElem;
curElem = curElem->fNext;
}
return 0;
}
template <class TElem> void ValueVectorOf<TElem>::
removeElementAt(const unsigned int removeAt)
{
if (removeAt >= fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
if (removeAt == fCurCount-1)
{
fCurCount--;
return;
}
// Copy down every element above remove point
for (unsigned int index = removeAt; index < fCurCount-1; index++)
fElemList[index] = fElemList[index+1];
// And bump down count
fCurCount--;
}
template <class TVal> const ValueHashTableBucketElem<TVal>* SimpleValueHashTableOf<TVal>::
findBucketElem(const void* const key, unsigned int& hashVal) const
{
// Hash the key
hashVal = fHash->getHashVal(key, fHashModulus);
if (hashVal > fHashModulus)
ThrowXML(RuntimeException, XMLExcepts::HshTbl_BadHashFromKey);
// Search that bucket for the key
const ValueHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
while (curElem)
{
if (fHash->equals(key, curElem->fKey))
return curElem;
curElem = curElem->fNext;
}
return 0;
}
template <class TElem> void ValueVectorOf<TElem>::
insertElementAt(const TElem& toInsert, const unsigned int insertAt)
{
if (insertAt == fCurCount)
{
addElement(toInsert);
return;
}
if (insertAt > fCurCount)
ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
// Make room for the newbie
for (unsigned int index = fCurCount; index > insertAt; index--)
fElemList[index] = fElemList[index-1];
// And stick it in and bump the count
fElemList[insertAt] = toInsert;
fCurCount++;
}
void SAXImportHandlers::writeChars ( const XMLByte* const toWrite
# if XERCES_VERSION_MAJOR > 2
, XMLSize_t count
# else
, const unsigned int count
# endif
, XMLFormatter* const formatter)
{
/* format each piece of CDATA value based on other information */
int inlen = STlength((char *)toWrite);
if (!(isMetaInfoSet))
{
cerr<<"ERROR: Either table or table metadata information is not found."<<endl;
ThrowXML(RuntimeException, XMLExcepts::NoError);
}
/* collect the string parsed */
if (datalen == 0)
{
datalen = inlen;
MEcopy (toWrite, datalen, dataval);
}
else
{
int oldlen = datalen;
datalen += inlen;
/* Increase the buffer size to hold the value */
if (datalen > oldlen)
{
char *temp = dataval;
int factor = (datalen/(DB_MAXSTRING + 32)) + 1;
temp = (char *)MEreqmem(0, (DB_MAXSTRING + 32)*factor, TRUE, NULL);
MEcopy (dataval, oldlen, temp);
MEfree(dataval);
dataval = temp;
}
MEcopy (toWrite, inlen, dataval + oldlen);
}
}
XMLSize_t
MacOSTranscoder::transcodeFrom( const XMLByte* const srcData
, const XMLSize_t srcCount
, XMLCh* const toFill
, const XMLSize_t maxChars
, XMLSize_t& bytesEaten
, unsigned char* const charSizes)
{
// Reset the tec state (since we don't know that we're part of a
// larger run of text).
TECClearConverterContextInfo(mTextToUnicode);
// Do the conversion
ByteCount bytesConsumed = 0;
ByteCount bytesProduced = 0;
OSStatus status = TECConvertText(mTextToUnicode,
(ConstTextPtr) srcData,
srcCount, // inputBufferLength
&bytesConsumed, // actualInputLength
(TextPtr) toFill, // outputBuffer
maxChars * sizeof(XMLCh), // outputBufferLength
&bytesProduced); // actualOutputLength
// Ignorable error codes
if( status == kTECUsedFallbacksStatus
|| status == kTECOutputBufferFullStatus
|| status == kTECPartialCharErr
)
status = noErr;
if (status != noErr)
ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
std::size_t charsProduced = bytesProduced / sizeof(XMLCh);
bytesEaten = bytesConsumed;
return charsProduced;
}
//
// Call URLAccess to fullfill the read request. Since it
// passes us back buffers full of data, our object maintains
// a partial buffer across calls.
//
unsigned int
URLAccessBinInputStream::readBytes(XMLByte* const toFill
, const unsigned int maxToRead)
{
OSStatus status = noErr;
XMLByte* writePos = toFill;
std::size_t bytesDesired = maxToRead;
URLState state = kURLNullState;
while ( // while...
status == noErr // there's been no error
&& bytesDesired > 0 // more data is wanted
&& (status = URLGetCurrentState(mURLReference, &state)) == noErr // we can get the state
&& (state != kURLErrorOccurredState) // no error has occurred in the transaction
&& (mBuffer || state != kURLCompletedState) // we have data still buffered or the request isn't complete
&& (mBuffer || bytesDesired == maxToRead) // we have data still buffered or we've supplied absolutely none
)
{
// Give time to URLAccess
status = URLIdle();
// If we've got buffered data, use it
if (status == noErr && mBuffer)
{
// Supply as much as we can from the buffer
std::size_t n = mBufAvailable;
if (n > bytesDesired)
n = bytesDesired;
// If we've got data, copy it over and update our pointers
if (n > 0)
{
std::memcpy(writePos, mBufPos, n);
writePos += n;
bytesDesired -= n;
mBufPos += n;
mBufAvailable -= n;
mBytesProcessed += n;
}
// If we exhausted the buffer, release it
if (mBufAvailable == 0)
{
status = URLReleaseBuffer(mURLReference, mBuffer);
mBuffer = NULL;
}
}
// If the buffer is exhausted, get a new one
if (status == noErr && !mBuffer)
{
status = URLGetBuffer(mURLReference, &mBuffer, &mBufAvailable);
if (status == noErr)
mBufPos = reinterpret_cast<char*>(mBuffer);
}
}
// Throw on any error
if (status != noErr || state == kURLErrorOccurredState)
ThrowXML(NetAccessorException, XMLExcepts::NetAcc_ReadSocket);
// Return number of bytes delivered
return maxToRead - bytesDesired;
}
MacOSURLAccess::MacOSURLAccess()
{
// Ensure that we've got URLAccess
if (!URLAccessAvailable())
ThrowXML(NetAccessorException, XMLExcepts::NetAcc_InitFailed);
}
