bool RefHash3KeysIdPool<TVal, THasher>::
containsKey(const void* const key1, const int key2, const int key3) const
{
XMLSize_t hashVal;
const RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
return (findIt != 0);
}
template <class TVal> bool SimpleValueHashTableOf<TVal>::
containsKey(const void* const key) const
{
unsigned int hashVal;
const ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
return (findIt != 0);
}
bool Hash2KeysSetOf<THasher>::putIfNotPresent(const void* key1, int key2)
{
// First see if the key exists already
XMLSize_t hashVal;
Hash2KeysSetBucketElem* newBucket = findBucketElem(key1, key2, hashVal);
//
// If so,then update its value. If not, then we need to add it to
// the right bucket
//
if (newBucket)
return false;
// Apply 4 load factor to find threshold.
XMLSize_t threshold = fHashModulus * 4;
// If we've grown too big, expand the table and rehash.
if (fCount >= threshold)
rehash();
if(fAvailable==0)
newBucket = (Hash2KeysSetBucketElem*)fMemoryManager->allocate(sizeof(Hash2KeysSetBucketElem));
else
{
newBucket = fAvailable;
fAvailable = fAvailable->fNext;
}
newBucket->fKey1 = key1;
newBucket->fKey2 = key2;
newBucket->fNext = fBucketList[hashVal];
fBucketList[hashVal] = newBucket;
fCount++;
return true;
}
bool ValueHashTableOf<TVal, THasher>::
containsKey(const void* const key) const
{
XMLSize_t hashVal;
const ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
return (findIt != 0);
}
inline const TVal* RefHashTableOf<TVal, THasher>::
get(const void* const key) const
{
XMLSize_t hashVal;
const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
return findIt ? findIt->fData : 0;
}
// ---------------------------------------------------------------------------
// NameIdPool: Element management
// ---------------------------------------------------------------------------
template <class TElem> bool
NameIdPool<TElem>::containsKey(const XMLCh* const key) const
{
unsigned int hashVal;
const NameIdPoolBucketElem<TElem>* findIt = findBucketElem(key, hashVal);
return (findIt != 0);
}
// ---------------------------------------------------------------------------
// RefHash2KeysTableOf: Putters
// ---------------------------------------------------------------------------
template <class TVal> void RefHash2KeysTableOf<TVal>::put(void* key1, int key2, TVal* const valueToAdopt)
{
// Apply 4 load factor to find threshold.
unsigned int threshold = fHashModulus * 4;
// If we've grown too big, expand the table and rehash.
if (fCount >= threshold)
rehash();
// First see if the key exists already
unsigned int hashVal;
RefHash2KeysTableBucketElem<TVal>* newBucket = findBucketElem(key1, key2, hashVal);
//
// If so,then update its value. If not, then we need to add it to
// the right bucket
//
if (newBucket)
{
if (fAdoptedElems)
delete newBucket->fData;
newBucket->fData = valueToAdopt;
newBucket->fKey1 = key1;
newBucket->fKey2 = key2;
}
else
{
newBucket =
new (fMemoryManager->allocate(sizeof(RefHash2KeysTableBucketElem<TVal>)))
RefHash2KeysTableBucketElem<TVal>(key1, key2, valueToAdopt, fBucketList[hashVal]);
fBucketList[hashVal] = newBucket;
fCount++;
}
}
template <class TVal> bool RefHash3KeysIdPool<TVal>::
containsKey(const void* const key1, const int key2, const int key3) const
{
unsigned int hashVal;
const RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
return (findIt != 0);
}
void RefHashTableOf<TVal, THasher>::put(void* key, TVal* const valueToAdopt)
{
// Apply 0.75 load factor to find threshold.
XMLSize_t threshold = fHashModulus * 3 / 4;
// If we've grown too big, expand the table and rehash.
if (fCount >= threshold)
rehash();
// First see if the key exists already
XMLSize_t hashVal;
RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
//
// If so,then update its value. If not, then we need to add it to
// the right bucket
//
if (newBucket)
{
if (fAdoptedElems)
delete newBucket->fData;
newBucket->fData = valueToAdopt;
newBucket->fKey = key;
}
else
{
newBucket =
new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
fBucketList[hashVal] = newBucket;
fCount++;
}
}
bool DOMDeepNodeListPool<TVal>::containsKey( const void* const key1
, const XMLCh* const key2
, const XMLCh* const key3) const
{
XMLSize_t hashVal;
const DOMDeepNodeListPoolTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
return (findIt != 0);
}
// ---------------------------------------------------------------------------
// RefHashTableOf: Getters
// ---------------------------------------------------------------------------
template <class TVal> TVal* RefHashTableOf<TVal>::get(const void* const key)
{
unsigned int hashVal;
RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
return 0;
return findIt->fData;
}
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;
}
TVal& ValueHashTableOf<TVal, THasher>::get(const void* const key, MemoryManager* const manager)
{
XMLSize_t hashVal;
ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists, manager);
return findIt->fData;
}
const TVal*
RefHash3KeysIdPool<TVal, THasher>::getByKey(const void* const key1, const int key2, const int key3) const
{
XMLSize_t hashVal;
const RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
if (!findIt)
return 0;
return findIt->fData;
}
template <class TElem> const TElem*
NameIdPool<TElem>::getByKey(const XMLCh* const key) const
{
unsigned int hashVal;
const NameIdPoolBucketElem<TElem>* findIt = findBucketElem(key, hashVal);
if (!findIt)
return 0;
return findIt->fData;
}
template <class TVal> const TVal*
DOMDeepNodeListPool<TVal>::getByKey(const void* const key1, const XMLCh* const key2, const XMLCh* const key3) const
{
XMLSize_t hashVal;
const DOMDeepNodeListPoolTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
if (!findIt)
return 0;
return findIt->fData;
}
template <class TVal> const TVal*
RefHash3KeysIdPool<TVal>::getByKey(const void* const key1, const int key2, const int key3) const
{
unsigned int hashVal;
const RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
if (!findIt)
return 0;
return findIt->fData;
}
template <class TVal> const TVal& ValueHashTableOf<TVal>::
get(const void* const key) const
{
unsigned int hashVal;
const ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists, fMemoryManager);
return findIt->fData;
}
unsigned int NameIdPool<TElem>::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<TElem>* newBucket = new (fMemoryManager) NameIdPoolBucketElem<TElem>
(
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;
}
// ---------------------------------------------------------------------------
// SimpleValueHashTableOf: Putters
// ---------------------------------------------------------------------------
template <class TVal> void SimpleValueHashTableOf<TVal>::put(void* key, const TVal& valueToAdopt)
{
// First see if the key exists already
unsigned int hashVal;
ValueHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
//
// If so,then update its value. If not, then we need to add it to
// the right bucket
//
if (newBucket)
{
newBucket->fData = valueToAdopt;
newBucket->fKey = key;
}
else
{
newBucket = new ValueHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
fBucketList[hashVal] = newBucket;
}
}
// ---------------------------------------------------------------------------
// RefHash2KeysTableOf: Putters
// ---------------------------------------------------------------------------
template <class TVal> void RefHash2KeysTableOf<TVal>::put(void* key1, int key2, TVal* const valueToAdopt)
{
// First see if the key exists already
unsigned int hashVal;
RefHash2KeysTableBucketElem<TVal>* newBucket = findBucketElem(key1, key2, hashVal);
//
// If so,then update its value. If not, then we need to add it to
// the right bucket
//
if (newBucket)
{
if (fAdoptedElems)
delete newBucket->fData;
newBucket->fData = valueToAdopt;
newBucket->fKey1 = key1;
newBucket->fKey2 = key2;
}
else
{
newBucket = new (fMemoryManager) RefHash2KeysTableBucketElem<TVal>(key1, key2, valueToAdopt, fBucketList[hashVal]);
fBucketList[hashVal] = newBucket;
}
}
bool Hash2KeysSetOf<THasher>::containsKey(const void* const key1, const int key2) const
{
XMLSize_t hashVal;
const Hash2KeysSetBucketElem* findIt = findBucketElem(key1, key2, hashVal);
return (findIt != 0);
}
// ---------------------------------------------------------------------------
// DOMDeepNodeListPool: Putters
// ---------------------------------------------------------------------------
template <class TVal> XMLSize_t
DOMDeepNodeListPool<TVal>::put(void* key1, XMLCh* key2, XMLCh* key3, TVal* const valueToAdopt)
{
// First see if the key exists already
XMLSize_t hashVal;
DOMDeepNodeListPoolTableBucketElem<TVal>* newBucket = findBucketElem(key1, key2, key3, hashVal);
//
// If so,then update its value. If not, then we need to add it to
// the right bucket
//
if (newBucket)
{
if (fAdoptedElems)
delete newBucket->fData;
fMemoryManager->deallocate(newBucket->fKey2);//delete[] newBucket->fKey2;
fMemoryManager->deallocate(newBucket->fKey3);//delete[] newBucket->fKey3;
newBucket->fData = valueToAdopt;
newBucket->fKey1 = key1;
newBucket->fKey2 = XMLString::replicate(key2, fMemoryManager);
newBucket->fKey3 = XMLString::replicate(key3, fMemoryManager);
}
else
{
// Revisit: the gcc compiler 2.95.x is generating an
// internal compiler error message. So we use the default
// memory manager for now.
#if defined (XML_GCC_VERSION) && (XML_GCC_VERSION < 29600)
newBucket = new DOMDeepNodeListPoolTableBucketElem<TVal>
(
key1
, key2
, key3
, valueToAdopt
, fBucketList[hashVal]
, fMemoryManager
);
#else
newBucket = new (fMemoryManager) DOMDeepNodeListPoolTableBucketElem<TVal>
(
key1
, key2
, key3
, valueToAdopt
, fBucketList[hashVal]
, fMemoryManager
);
#endif
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
XMLSize_t newCount = (XMLSize_t)(fIdPtrsCount * 1.5);
TVal** newArray = (TVal**) fMemoryManager->allocate
(
newCount * sizeof(TVal*)
);//new TVal*[newCount];
// Copy over the old contents to the new array
memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TVal*));
// Ok, toss the old array and store the new data
fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
fIdPtrs = newArray;
fIdPtrsCount = newCount;
}
const XMLSize_t retId = ++fIdCounter;
fIdPtrs[retId] = valueToAdopt;
// Return the id that we gave to this element
return retId;
}
// this function transfer the data from key1 to key2
template <class TVal> void RefHash2KeysTableOf<TVal>::transferElement(const void* const key1, void* key2)
{
// Hash the key
unsigned int hashVal = fHash->getHashVal(key1, fHashModulus);
assert(hashVal < fHashModulus);
//
// Search the given bucket for this key. Keep up with the previous
// element so we can patch around it.
//
RefHash2KeysTableBucketElem<TVal>* curElem = fBucketList[hashVal];
RefHash2KeysTableBucketElem<TVal>* lastElem = 0;
while (curElem)
{
// if this element has the same primary key, remove it and add it using the new primary key
if (fHash->equals(key1, curElem->fKey1))
{
if (!lastElem)
{
// It was the first in the bucket
fBucketList[hashVal] = curElem->fNext;
}
else
{
// Patch around the current element
lastElem->fNext = curElem->fNext;
}
// this code comes from put(), but it doesn't update fCount
unsigned int hashVal2;
RefHash2KeysTableBucketElem<TVal>* newBucket = findBucketElem(key2, curElem->fKey2, hashVal2);
if (newBucket)
{
if (fAdoptedElems)
delete newBucket->fData;
newBucket->fData = curElem->fData;
newBucket->fKey1 = key2;
newBucket->fKey2 = curElem->fKey2;
}
else
{
newBucket =
new (fMemoryManager->allocate(sizeof(RefHash2KeysTableBucketElem<TVal>)))
RefHash2KeysTableBucketElem<TVal>(key2, curElem->fKey2, curElem->fData, fBucketList[hashVal2]);
fBucketList[hashVal2] = newBucket;
}
RefHash2KeysTableBucketElem<TVal>* elemToDelete = curElem;
// Update just curElem; lastElem must stay the same
curElem = curElem->fNext;
// Delete the current element
// delete elemToDelete;
// destructor is empty...
// curElem->~RefHash2KeysTableBucketElem();
fMemoryManager->deallocate(elemToDelete);
}
else
{
// Move both pointers upwards
lastElem = curElem;
curElem = curElem->fNext;
}
}
}
