/* * Copyright 1999-2000,2004 The Apache Software Foundation. * * Licensed 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. */ /** * $Log: NameIdPool.c,v $ * Revision 1.9 2004/09/08 13:56:22 peiyongz * Apache License Version 2.0 * * Revision 1.8 2003/12/17 00:18:35 cargilld * Update to memory management so that the static memory manager (one used to call Initialize) is only for static data. * * Revision 1.7 2003/10/29 16:18:05 peiyongz * size() added and Reset() bug fixed * * Revision 1.6 2003/05/16 06:01:52 knoaman * Partial implementation of the configurable memory manager. * * Revision 1.5 2003/05/15 19:04:35 knoaman * Partial implementation of the configurable memory manager. * * Revision 1.4 2002/11/04 15:22:04 tng * C++ Namespace Support. * * Revision 1.3 2002/09/24 19:51:24 tng * Performance: use XMLString::equals instead of XMLString::compareString * * Revision 1.2 2002/05/08 19:05:29 knoaman * [Bug 7701] NameIdPoolEnumerator copy constructor should call base class - fix by Martin Kalen * * Revision 1.1.1.1 2002/02/01 22:22:11 peiyongz * sane_include * * Revision 1.3 2000/03/02 19:54:42 roddey * This checkin includes many changes done while waiting for the * 1.1.0 code to be finished. I can't list them all here, but a list is * available elsewhere. * * Revision 1.2 2000/02/06 07:48:02 rahulj * Year 2K copyright swat. * * Revision 1.1.1.1 1999/11/09 01:04:47 twl * Initial checkin * * Revision 1.3 1999/11/08 20:45:10 rahul * Swat for adding in Product name and CVS comment log variable. * */ // --------------------------------------------------------------------------- // Includes // --------------------------------------------------------------------------- #if defined(XERCES_TMPLSINC) #include #endif #include #include #include XERCES_CPP_NAMESPACE_BEGIN // --------------------------------------------------------------------------- // NameIdPoolBucketElem: Constructors and Destructor // --------------------------------------------------------------------------- template NameIdPoolBucketElem:: NameIdPoolBucketElem(TElem* const value , NameIdPoolBucketElem* const next) : fData(value) , fNext(next) { } template NameIdPoolBucketElem::~NameIdPoolBucketElem() { // Nothing to do } // --------------------------------------------------------------------------- // NameIdPool: Constructors and Destructor // --------------------------------------------------------------------------- template NameIdPool::NameIdPool( const unsigned int hashModulus , const unsigned int initSize , MemoryManager* const manager) : fMemoryManager(manager) , fBucketList(0) , fIdPtrs(0) , fIdPtrsCount(initSize) , fIdCounter(0) , fHashModulus(hashModulus) { if (!fHashModulus) ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_ZeroModulus, fMemoryManager); // Allocate the bucket list and zero them fBucketList = (NameIdPoolBucketElem**) fMemoryManager->allocate ( fHashModulus * sizeof(NameIdPoolBucketElem*) ); //new NameIdPoolBucketElem*[fHashModulus]; for (unsigned int index = 0; index < fHashModulus; index++) fBucketList[index] = 0; // // Allocate the initial id pointers array. We don't have to zero them // out since the fIdCounter value tells us which ones are valid. The // zeroth element is never used (and represents an invalid pool id.) // if (!fIdPtrsCount) fIdPtrsCount = 256; fIdPtrs = (TElem**) fMemoryManager->allocate ( fIdPtrsCount * sizeof(TElem*) ); //new TElem*[fIdPtrsCount]; fIdPtrs[0] = 0; } template NameIdPool::~NameIdPool() { // // Delete the id pointers list. The stuff it points to will be cleaned // up when we clean the bucket lists. // fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs; // Remove all elements then delete the bucket list removeAll(); fMemoryManager->deallocate(fBucketList); //delete [] fBucketList; } // --------------------------------------------------------------------------- // NameIdPool: Element management // --------------------------------------------------------------------------- template bool NameIdPool::containsKey(const XMLCh* const key) const { unsigned int hashVal; const NameIdPoolBucketElem* findIt = findBucketElem(key, hashVal); return (findIt != 0); } template void NameIdPool::removeAll() { // Clean up the buckets first for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++) { NameIdPoolBucketElem* curElem = fBucketList[buckInd]; NameIdPoolBucketElem* nextElem; while (curElem) { // Save the next element before we hose this one nextElem = curElem->fNext; delete curElem->fData; delete curElem; curElem = nextElem; } // Empty out the bucket fBucketList[buckInd] = 0; } // Reset the id counter fIdCounter = 0; } // --------------------------------------------------------------------------- // NameIdPool: Getters // --------------------------------------------------------------------------- template TElem* NameIdPool::getByKey(const XMLCh* const key) { unsigned int hashVal; NameIdPoolBucketElem* findIt = findBucketElem(key, hashVal); if (!findIt) return 0; return findIt->fData; } template const TElem* NameIdPool::getByKey(const XMLCh* const key) const { unsigned int hashVal; const NameIdPoolBucketElem* findIt = findBucketElem(key, hashVal); if (!findIt) return 0; return findIt->fData; } template TElem* NameIdPool::getById(const unsigned int elemId) { // If its either zero or beyond our current id, its an error if (!elemId || (elemId > fIdCounter)) ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_InvalidId, fMemoryManager); return fIdPtrs[elemId]; } template const TElem* NameIdPool::getById(const unsigned int elemId) const { // If its either zero or beyond our current id, its an error if (!elemId || (elemId > fIdCounter)) ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_InvalidId, fMemoryManager); return fIdPtrs[elemId]; } template MemoryManager* NameIdPool::getMemoryManager() const { return fMemoryManager; } // --------------------------------------------------------------------------- // NameIdPool: Setters // --------------------------------------------------------------------------- template unsigned int NameIdPool::put(TElem* const elemToAdopt) { // First see if the key exists already. If so, its an error unsigned int hashVal; if (findBucketElem(elemToAdopt->getKey(), hashVal)) { ThrowXMLwithMemMgr1 ( IllegalArgumentException , XMLExcepts::Pool_ElemAlreadyExists , elemToAdopt->getKey() , fMemoryManager ); } // Create a new bucket element and add it to the appropriate list NameIdPoolBucketElem* newBucket = new (fMemoryManager) NameIdPoolBucketElem ( elemToAdopt , fBucketList[hashVal] ); fBucketList[hashVal] = newBucket; // // Give this new one the next available id and add to the pointer list. // Expand the list if that is now required. // if (fIdCounter + 1 == fIdPtrsCount) { // Create a new count 1.5 times larger and allocate a new array unsigned int newCount = (unsigned int)(fIdPtrsCount * 1.5); TElem** newArray = (TElem**) fMemoryManager->allocate ( newCount * sizeof(TElem*) ); //new TElem*[newCount]; // Copy over the old contents to the new array memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TElem*)); // Ok, toss the old array and store the new data fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs; fIdPtrs = newArray; fIdPtrsCount = newCount; } const unsigned int retId = ++fIdCounter; fIdPtrs[retId] = elemToAdopt; // Set the id on the passed element elemToAdopt->setId(retId); // Return the id that we gave to this element return retId; } // --------------------------------------------------------------------------- // NameIdPool: Private methods // --------------------------------------------------------------------------- template NameIdPoolBucketElem* NameIdPool:: findBucketElem(const XMLCh* const key, unsigned int& hashVal) { // Hash the key hashVal = XMLString::hash(key, fHashModulus, fMemoryManager); if (hashVal > fHashModulus) ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Pool_BadHashFromKey, fMemoryManager); // Search that bucket for the key NameIdPoolBucketElem* curElem = fBucketList[hashVal]; while (curElem) { if (XMLString::equals(key, curElem->fData->getKey())) return curElem; curElem = curElem->fNext; } return 0; } template const NameIdPoolBucketElem* NameIdPool:: findBucketElem(const XMLCh* const key, unsigned int& hashVal) const { // Hash the key hashVal = XMLString::hash(key, fHashModulus, fMemoryManager); if (hashVal > fHashModulus) ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Pool_BadHashFromKey, fMemoryManager); // Search that bucket for the key const NameIdPoolBucketElem* curElem = fBucketList[hashVal]; while (curElem) { if (XMLString::equals(key, curElem->fData->getKey())) return curElem; curElem = curElem->fNext; } return 0; } // --------------------------------------------------------------------------- // NameIdPoolEnumerator: Constructors and Destructor // --------------------------------------------------------------------------- template NameIdPoolEnumerator:: NameIdPoolEnumerator(NameIdPool* const toEnum , MemoryManager* const manager) : XMLEnumerator() , fCurIndex(0) , fToEnum(toEnum) , fMemoryManager(manager) { Reset(); } template NameIdPoolEnumerator:: NameIdPoolEnumerator(const NameIdPoolEnumerator& toCopy) : fCurIndex(toCopy.fCurIndex) , fToEnum(toCopy.fToEnum) , fMemoryManager(toCopy.fMemoryManager) { } template NameIdPoolEnumerator::~NameIdPoolEnumerator() { // We don't own the pool being enumerated, so no cleanup required } // --------------------------------------------------------------------------- // NameIdPoolEnumerator: Public operators // --------------------------------------------------------------------------- template NameIdPoolEnumerator& NameIdPoolEnumerator:: operator=(const NameIdPoolEnumerator& toAssign) { if (this == &toAssign) return *this; fMemoryManager = toAssign.fMemoryManager; fCurIndex = toAssign.fCurIndex; fToEnum = toAssign.fToEnum; return *this; } // --------------------------------------------------------------------------- // NameIdPoolEnumerator: Enum interface // --------------------------------------------------------------------------- template bool NameIdPoolEnumerator:: hasMoreElements() const { // If our index is zero or past the end, then we are done if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter)) return false; return true; } template TElem& NameIdPoolEnumerator::nextElement() { // If our index is zero or past the end, then we are done if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter)) ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::Enum_NoMoreElements, fMemoryManager); // Return the current element and bump the index return *fToEnum->fIdPtrs[fCurIndex++]; } template void NameIdPoolEnumerator::Reset() { // // Find the next available bucket element in the pool. We use the id // array since its very easy to enumerator through by just maintaining // an index. If the id counter is zero, then its empty and we leave the // current index to zero. // fCurIndex = fToEnum->fIdCounter ? 1:0; } template int NameIdPoolEnumerator::size() const { return fToEnum->fIdCounter; } XERCES_CPP_NAMESPACE_END