// 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); }