You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by am...@apache.org on 2008/07/15 15:27:51 UTC
svn commit: r676911 [3/5] - in /xerces/c/trunk: samples/src/PSVIWriter/
samples/src/SAX2Print/ samples/src/SAXPrint/ samples/src/SCMPrint/
src/xercesc/dom/impl/ src/xercesc/framework/ src/xercesc/internal/
src/xercesc/parsers/ src/xercesc/util/ src/xer...
Modified: xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.c Tue Jul 15 06:27:32 2008
@@ -38,7 +38,7 @@
// RefHash2KeysTableOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TVal>
-RefHash2KeysTableOf<TVal>::RefHash2KeysTableOf( const unsigned int modulus
+RefHash2KeysTableOf<TVal>::RefHash2KeysTableOf( const XMLSize_t modulus
, const bool adoptElems
, MemoryManager* const manager)
: fMemoryManager(manager)
@@ -52,7 +52,7 @@
}
template <class TVal>
-RefHash2KeysTableOf<TVal>::RefHash2KeysTableOf( const unsigned int modulus
+RefHash2KeysTableOf<TVal>::RefHash2KeysTableOf( const XMLSize_t modulus
, const bool adoptElems
, HashBase* hashBase
, MemoryManager* const manager)
@@ -69,7 +69,7 @@
}
template <class TVal>
-RefHash2KeysTableOf<TVal>::RefHash2KeysTableOf(const unsigned int modulus,
+RefHash2KeysTableOf<TVal>::RefHash2KeysTableOf(const XMLSize_t modulus,
MemoryManager* const manager)
: fMemoryManager(manager)
, fAdoptedElems(true)
@@ -82,7 +82,7 @@
}
template <class TVal>
-void RefHash2KeysTableOf<TVal>::initialize(const unsigned int modulus)
+void RefHash2KeysTableOf<TVal>::initialize(const XMLSize_t modulus)
{
if (modulus == 0)
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
@@ -118,7 +118,7 @@
template <class TVal> bool RefHash2KeysTableOf<TVal>::
containsKey(const void* const key1, const int key2) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const RefHash2KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, hashVal);
return (findIt != 0);
}
@@ -127,7 +127,7 @@
removeKey(const void* const key1, const int key2)
{
// Hash the key
- unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
+ XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
assert(hashVal < fHashModulus);
//
@@ -178,7 +178,7 @@
removeKey(const void* const key1)
{
// Hash the key
- unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
+ XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
assert(hashVal < fHashModulus);
//
@@ -232,7 +232,7 @@
return;
// Clean up the buckets first
- for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++)
+ for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
{
// Get the bucket list head for this entry
RefHash2KeysTableBucketElem<TVal>* curElem = fBucketList[buckInd];
@@ -266,7 +266,7 @@
template <class TVal> void RefHash2KeysTableOf<TVal>::transferElement(const void* const key1, void* key2)
{
// Hash the key
- unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
+ XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
assert(hashVal < fHashModulus);
//
@@ -293,7 +293,7 @@
}
// this code comes from put(), but it doesn't update fCount
- unsigned int hashVal2;
+ XMLSize_t hashVal2;
RefHash2KeysTableBucketElem<TVal>* newBucket = findBucketElem(key2, curElem->fKey2, hashVal2);
if (newBucket)
{
@@ -338,7 +338,7 @@
// ---------------------------------------------------------------------------
template <class TVal> TVal* RefHash2KeysTableOf<TVal>::get(const void* const key1, const int key2)
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
RefHash2KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, hashVal);
if (!findIt)
return 0;
@@ -348,7 +348,7 @@
template <class TVal> const TVal* RefHash2KeysTableOf<TVal>::
get(const void* const key1, const int key2) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const RefHash2KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, hashVal);
if (!findIt)
return 0;
@@ -362,7 +362,7 @@
}
template <class TVal>
-unsigned int RefHash2KeysTableOf<TVal>::getHashModulus() const
+XMLSize_t RefHash2KeysTableOf<TVal>::getHashModulus() const
{
return fHashModulus;
}
@@ -373,14 +373,14 @@
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;
+ XMLSize_t 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;
+ XMLSize_t hashVal;
RefHash2KeysTableBucketElem<TVal>* newBucket = findBucketElem(key1, key2, hashVal);
//
@@ -411,7 +411,7 @@
// RefHash2KeysTableOf: Private methods
// ---------------------------------------------------------------------------
template <class TVal> RefHash2KeysTableBucketElem<TVal>* RefHash2KeysTableOf<TVal>::
-findBucketElem(const void* const key1, const int key2, unsigned int& hashVal)
+findBucketElem(const void* const key1, const int key2, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
@@ -430,7 +430,7 @@
}
template <class TVal> const RefHash2KeysTableBucketElem<TVal>* RefHash2KeysTableOf<TVal>::
-findBucketElem(const void* const key1, const int key2, unsigned int& hashVal) const
+findBucketElem(const void* const key1, const int key2, XMLSize_t& hashVal) const
{
// Hash the key
hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
@@ -452,7 +452,7 @@
template <class TVal> void RefHash2KeysTableOf<TVal>::
rehash()
{
- const unsigned int newMod = (fHashModulus * 8)+1;
+ const XMLSize_t newMod = (fHashModulus * 8)+1;
RefHash2KeysTableBucketElem<TVal>** newBucketList =
(RefHash2KeysTableBucketElem<TVal>**) fMemoryManager->allocate
@@ -467,7 +467,7 @@
memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
// Rehash all existing entries.
- for (unsigned int index = 0; index < fHashModulus; index++)
+ for (XMLSize_t index = 0; index < fHashModulus; index++)
{
// Get the bucket list head for this entry
RefHash2KeysTableBucketElem<TVal>* curElem = fBucketList[index];
@@ -476,7 +476,7 @@
// Save the next element before we detach this one
RefHash2KeysTableBucketElem<TVal>* nextElem = curElem->fNext;
- const unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)curElem->fKey1, newMod, fMemoryManager) : fHash->getHashVal(curElem->fKey1, newMod, fMemoryManager);
+ const XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)curElem->fKey1, newMod, fMemoryManager) : fHash->getHashVal(curElem->fKey1, newMod, fMemoryManager);
assert(hashVal < newMod);
RefHash2KeysTableBucketElem<TVal>* newHeadElem = newBucketList[hashVal];
@@ -588,7 +588,7 @@
if(fLockPrimaryKey)
fCurHash=fToEnum->fHash==0?XMLString::hash((const XMLCh*)fLockPrimaryKey, fToEnum->fHashModulus, fMemoryManager) : fToEnum->fHash->getHashVal(fLockPrimaryKey, fToEnum->fHashModulus, fMemoryManager);
else
- fCurHash = (unsigned int)-1;
+ fCurHash = (XMLSize_t)-1;
fCurElem = 0;
findNext();
}
Modified: xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/RefHash2KeysTableOf.hpp Tue Jul 15 06:27:32 2008
@@ -78,13 +78,13 @@
// backwards compatability - default hasher is HashXMLCh
RefHash2KeysTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
// backwards compatability - default hasher is HashXMLCh
RefHash2KeysTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, const bool adoptElems
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -93,7 +93,7 @@
// may delete the hasher of a different hashtable if both use the same hasher.
RefHash2KeysTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, const bool adoptElems
, HashBase* hashBase
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
@@ -118,7 +118,7 @@
const TVal* get(const void* const key1, const int key2) const;
MemoryManager* getMemoryManager() const;
- unsigned int getHashModulus() const;
+ XMLSize_t getHashModulus() const;
// -----------------------------------------------------------------------
// Putters
@@ -142,9 +142,9 @@
// -----------------------------------------------------------------------
// Private methods
// -----------------------------------------------------------------------
- RefHash2KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, unsigned int& hashVal);
- const RefHash2KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, unsigned int& hashVal) const;
- void initialize(const unsigned int modulus);
+ RefHash2KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, XMLSize_t& hashVal);
+ const RefHash2KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, XMLSize_t& hashVal) const;
+ void initialize(const XMLSize_t modulus);
void rehash();
@@ -173,8 +173,8 @@
MemoryManager* fMemoryManager;
bool fAdoptedElems;
RefHash2KeysTableBucketElem<TVal>** fBucketList;
- unsigned int fHashModulus;
- unsigned int fCount;
+ XMLSize_t fHashModulus;
+ XMLSize_t fCount;
HashBase* fHash;
};
@@ -247,7 +247,7 @@
// -----------------------------------------------------------------------
bool fAdopted;
RefHash2KeysTableBucketElem<TVal>* fCurElem;
- unsigned int fCurHash;
+ XMLSize_t fCurHash;
RefHash2KeysTableOf<TVal>* fToEnum;
MemoryManager* const fMemoryManager;
const void* fLockPrimaryKey;
Modified: xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.c (original)
+++ xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.c Tue Jul 15 06:27:32 2008
@@ -37,9 +37,9 @@
// RefHash3KeysIdPool: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TVal>
-RefHash3KeysIdPool<TVal>::RefHash3KeysIdPool( const unsigned int modulus
+RefHash3KeysIdPool<TVal>::RefHash3KeysIdPool( const XMLSize_t modulus
, const bool adoptElems
- , const unsigned int initSize
+ , const XMLSize_t initSize
, MemoryManager* const manager) :
fMemoryManager(manager)
, fAdoptedElems(adoptElems)
@@ -64,10 +64,10 @@
}
template <class TVal>
-RefHash3KeysIdPool<TVal>::RefHash3KeysIdPool( const unsigned int modulus
+RefHash3KeysIdPool<TVal>::RefHash3KeysIdPool( const XMLSize_t modulus
, const bool adoptElems
, HashBase* hashBase
- , const unsigned int initSize
+ , const XMLSize_t initSize
, MemoryManager* const manager) :
fMemoryManager(manager)
, fAdoptedElems(adoptElems)
@@ -94,8 +94,8 @@
}
template <class TVal>
-RefHash3KeysIdPool<TVal>::RefHash3KeysIdPool( const unsigned int modulus
- , const unsigned int initSize
+RefHash3KeysIdPool<TVal>::RefHash3KeysIdPool( const XMLSize_t modulus
+ , const XMLSize_t initSize
, MemoryManager* const manager) :
fMemoryManager(manager)
, fAdoptedElems(true)
@@ -119,7 +119,7 @@
fIdPtrs[0] = 0;
}
-template <class TVal> void RefHash3KeysIdPool<TVal>::initialize(const unsigned int modulus)
+template <class TVal> void RefHash3KeysIdPool<TVal>::initialize(const XMLSize_t modulus)
{
if (modulus == 0)
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
@@ -152,7 +152,7 @@
template <class TVal> bool RefHash3KeysIdPool<TVal>::isEmpty() const
{
// Just check the bucket list for non-empty elements
- for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++)
+ for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
{
if (fBucketList[buckInd] != 0)
return false;
@@ -163,7 +163,7 @@
template <class TVal> bool RefHash3KeysIdPool<TVal>::
containsKey(const void* const key1, const int key2, const int key3) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
return (findIt != 0);
}
@@ -173,7 +173,7 @@
if (fIdCounter == 0) return;
// Clean up the buckets first
- for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++)
+ for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
{
// Get the bucket list head for this entry
RefHash3KeysTableBucketElem<TVal>* curElem = fBucketList[buckInd];
@@ -213,7 +213,7 @@
template <class TVal> TVal*
RefHash3KeysIdPool<TVal>::getByKey(const void* const key1, const int key2, const int key3)
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
if (!findIt)
return 0;
@@ -223,7 +223,7 @@
template <class TVal> const TVal*
RefHash3KeysIdPool<TVal>::getByKey(const void* const key1, const int key2, const int key3) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const RefHash3KeysTableBucketElem<TVal>* findIt = findBucketElem(key1, key2, key3, hashVal);
if (!findIt)
return 0;
@@ -257,7 +257,7 @@
}
template <class TVal>
-unsigned int RefHash3KeysIdPool<TVal>::getHashModulus() const
+XMLSize_t RefHash3KeysIdPool<TVal>::getHashModulus() const
{
return fHashModulus;
}
@@ -265,12 +265,12 @@
// ---------------------------------------------------------------------------
// RefHash3KeysIdPool: Putters
// ---------------------------------------------------------------------------
-template <class TVal> unsigned int
+template <class TVal> XMLSize_t
RefHash3KeysIdPool<TVal>::put(void* key1, int key2, int key3, TVal* const valueToAdopt)
{
// First see if the key exists already
- unsigned int hashVal;
- unsigned int retId;
+ XMLSize_t hashVal;
+ XMLSize_t retId;
RefHash3KeysTableBucketElem<TVal>* newBucket = findBucketElem(key1, key2, key3, hashVal);
//
@@ -308,7 +308,7 @@
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);
+ XMLSize_t newCount = (XMLSize_t)(fIdPtrsCount * 1.5);
TVal** newArray = (TVal**) fMemoryManager->allocate
(
newCount * sizeof(TVal*)
@@ -338,7 +338,7 @@
// RefHash3KeysIdPool: Private methods
// ---------------------------------------------------------------------------
template <class TVal> RefHash3KeysTableBucketElem<TVal>* RefHash3KeysIdPool<TVal>::
-findBucketElem(const void* const key1, const int key2, const int key3, unsigned int& hashVal)
+findBucketElem(const void* const key1, const int key2, const int key3, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
@@ -357,7 +357,7 @@
}
template <class TVal> const RefHash3KeysTableBucketElem<TVal>* RefHash3KeysIdPool<TVal>::
-findBucketElem(const void* const key1, const int key2, const int key3, unsigned int& hashVal) const
+findBucketElem(const void* const key1, const int key2, const int key3, XMLSize_t& hashVal) const
{
// Hash the key
hashVal = fHash==0?XMLString::hash((const XMLCh*)key1, fHashModulus, fMemoryManager) : fHash->getHashVal(key1, fHashModulus, fMemoryManager);
@@ -444,14 +444,14 @@
}
-template <class TVal> int RefHash3KeysIdPoolEnumerator<TVal>::size() const
+template <class TVal> XMLSize_t RefHash3KeysIdPoolEnumerator<TVal>::size() const
{
return fToEnum->fIdCounter;
}
template <class TVal> void RefHash3KeysIdPoolEnumerator<TVal>::resetKey()
{
- fCurHash = (unsigned int)-1;
+ fCurHash = (XMLSize_t)-1;
fCurElem = 0;
findNext();
}
Modified: xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/RefHash3KeysIdPool.hpp Tue Jul 15 06:27:32 2008
@@ -91,17 +91,17 @@
// backwards compatability - default hasher is HashXMLCh
RefHash3KeysIdPool
(
- const unsigned int modulus
- , const unsigned int initSize = 128
+ const XMLSize_t modulus
+ , const XMLSize_t initSize = 128
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
// backwards compatability - default hasher is HashXMLCh
RefHash3KeysIdPool
(
- const unsigned int modulus
+ const XMLSize_t modulus
, const bool adoptElems
- , const unsigned int initSize = 128
+ , const XMLSize_t initSize = 128
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -110,10 +110,10 @@
// may delete the hasher of a different hashtable if both use the same hasher.
RefHash3KeysIdPool
(
- const unsigned int modulus
+ const XMLSize_t modulus
, const bool adoptElems
, HashBase* hashBase
- , const unsigned int initSize = 128
+ , const XMLSize_t initSize = 128
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -137,12 +137,12 @@
const TVal* getById(const unsigned int elemId) const;
MemoryManager* getMemoryManager() const;
- unsigned int getHashModulus() const;
+ XMLSize_t getHashModulus() const;
// -----------------------------------------------------------------------
// Putters
// -----------------------------------------------------------------------
- unsigned int put(void* key1, int key2, int key3, TVal* const valueToAdopt);
+ XMLSize_t put(void* key1, int key2, int key3, TVal* const valueToAdopt);
private :
@@ -161,9 +161,9 @@
// -----------------------------------------------------------------------
// Private methods
// -----------------------------------------------------------------------
- RefHash3KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, const int key3, unsigned int& hashVal);
- const RefHash3KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, const int key3, unsigned int& hashVal) const;
- void initialize(const unsigned int modulus);
+ RefHash3KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, const int key3, XMLSize_t& hashVal);
+ const RefHash3KeysTableBucketElem<TVal>* findBucketElem(const void* const key1, const int key2, const int key3, XMLSize_t& hashVal) const;
+ void initialize(const XMLSize_t modulus);
// -----------------------------------------------------------------------
@@ -202,11 +202,11 @@
MemoryManager* fMemoryManager;
bool fAdoptedElems;
RefHash3KeysTableBucketElem<TVal>** fBucketList;
- unsigned int fHashModulus;
+ XMLSize_t fHashModulus;
HashBase* fHash;
TVal** fIdPtrs;
- unsigned int fIdPtrsCount;
- unsigned int fIdCounter;
+ XMLSize_t fIdPtrsCount;
+ XMLSize_t fIdCounter;
};
@@ -233,7 +233,7 @@
bool hasMoreElements() const;
TVal& nextElement();
void Reset();
- int size() const;
+ XMLSize_t size() const;
// -----------------------------------------------------------------------
// New interface
@@ -268,10 +268,10 @@
// The name id pool that is being enumerated.
// -----------------------------------------------------------------------
bool fAdoptedElems;
- unsigned int fCurIndex;
+ XMLSize_t fCurIndex;
RefHash3KeysIdPool<TVal>* fToEnum;
RefHash3KeysTableBucketElem<TVal>* fCurElem;
- unsigned int fCurHash;
+ XMLSize_t fCurHash;
MemoryManager* const fMemoryManager;
};
Modified: xerces/c/trunk/src/xercesc/util/RefHashTableOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefHashTableOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefHashTableOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/RefHashTableOf.c Tue Jul 15 06:27:32 2008
@@ -39,7 +39,7 @@
// RefHashTableOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TVal>
-RefHashTableOf<TVal>::RefHashTableOf( const unsigned int modulus
+RefHashTableOf<TVal>::RefHashTableOf( const XMLSize_t modulus
, const bool adoptElems
, MemoryManager* const manager)
@@ -56,7 +56,7 @@
}
template <class TVal>
-RefHashTableOf<TVal>::RefHashTableOf( const unsigned int modulus
+RefHashTableOf<TVal>::RefHashTableOf( const XMLSize_t modulus
, const bool adoptElems
, HashBase* hashBase
, MemoryManager* const manager)
@@ -75,7 +75,7 @@
}
template <class TVal>
-RefHashTableOf<TVal>::RefHashTableOf(const unsigned int modulus
+RefHashTableOf<TVal>::RefHashTableOf(const XMLSize_t modulus
, MemoryManager* const manager)
: fMemoryManager(manager)
@@ -89,7 +89,7 @@
initialize(modulus);
}
-template <class TVal> void RefHashTableOf<TVal>::initialize(const unsigned int modulus)
+template <class TVal> void RefHashTableOf<TVal>::initialize(const XMLSize_t modulus)
{
if (modulus == 0)
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
@@ -99,7 +99,7 @@
(
fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
); //new RefHashTableBucketElem<TVal>*[fHashModulus];
- for (unsigned int index = 0; index < fHashModulus; index++)
+ for (XMLSize_t index = 0; index < fHashModulus; index++)
fBucketList[index] = 0;
}
@@ -120,7 +120,7 @@
template <class TVal> bool RefHashTableOf<TVal>::
containsKey(const void* const key) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
return (findIt != 0);
}
@@ -129,7 +129,7 @@
removeKey(const void* const key)
{
// Hash the key
- unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)key, fHashModulus, fMemoryManager) : fHash->getHashVal(key, fHashModulus, fMemoryManager);
+ XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)key, fHashModulus, fMemoryManager) : fHash->getHashVal(key, fHashModulus, fMemoryManager);
assert(hashVal < fHashModulus);
//
@@ -187,7 +187,7 @@
return;
// Clean up the buckets first
- for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++)
+ for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
{
// Get the bucket list head for this entry
RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
@@ -228,7 +228,7 @@
{
// Hash the key
TVal* retVal = 0;
- unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)key, fHashModulus, fMemoryManager) : fHash->getHashVal(key, fHashModulus, fMemoryManager);
+ XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)key, fHashModulus, fMemoryManager) : fHash->getHashVal(key, fHashModulus, fMemoryManager);
assert(hashVal < fHashModulus);
//
@@ -329,7 +329,7 @@
// ---------------------------------------------------------------------------
template <class TVal> TVal* RefHashTableOf<TVal>::get(const void* const key)
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
return 0;
@@ -339,7 +339,7 @@
template <class TVal> const TVal* RefHashTableOf<TVal>::
get(const void* const key) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
return 0;
@@ -353,13 +353,13 @@
}
template <class TVal>
-unsigned int RefHashTableOf<TVal>::getHashModulus() const
+XMLSize_t RefHashTableOf<TVal>::getHashModulus() const
{
return fHashModulus;
}
template <class TVal>
-unsigned int RefHashTableOf<TVal>::getCount() const
+XMLSize_t RefHashTableOf<TVal>::getCount() const
{
return fCount;
}
@@ -379,14 +379,14 @@
template <class TVal> void RefHashTableOf<TVal>::put(void* key, TVal* const valueToAdopt)
{
// Apply 0.75 load factor to find threshold.
- unsigned int threshold = fHashModulus * 3 / 4;
+ 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
- unsigned int hashVal;
+ XMLSize_t hashVal;
RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
//
@@ -418,7 +418,7 @@
// ---------------------------------------------------------------------------
template <class TVal> void RefHashTableOf<TVal>::rehash()
{
- const unsigned int newMod = (fHashModulus * 2) + 1;
+ const XMLSize_t newMod = (fHashModulus * 2) + 1;
RefHashTableBucketElem<TVal>** newBucketList =
(RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
@@ -434,7 +434,7 @@
// Rehash all existing entries.
- for (unsigned int index = 0; index < fHashModulus; index++)
+ for (XMLSize_t index = 0; index < fHashModulus; index++)
{
// Get the bucket list head for this entry
RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
@@ -444,7 +444,7 @@
// Save the next element before we detach this one
RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
- const unsigned int hashVal = fHash==0?XMLString::hash((const XMLCh*)curElem->fKey, newMod, fMemoryManager) : fHash->getHashVal(curElem->fKey, newMod, fMemoryManager);
+ const XMLSize_t hashVal = fHash==0?XMLString::hash((const XMLCh*)curElem->fKey, newMod, fMemoryManager) : fHash->getHashVal(curElem->fKey, newMod, fMemoryManager);
assert(hashVal < newMod);
RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
@@ -470,7 +470,7 @@
}
template <class TVal> RefHashTableBucketElem<TVal>* RefHashTableOf<TVal>::
-findBucketElem(const void* const key, unsigned int& hashVal)
+findBucketElem(const void* const key, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHash==0?XMLString::hash((const XMLCh*)key, fHashModulus, fMemoryManager) : fHash->getHashVal(key, fHashModulus, fMemoryManager);
@@ -489,7 +489,7 @@
}
template <class TVal> const RefHashTableBucketElem<TVal>* RefHashTableOf<TVal>::
-findBucketElem(const void* const key, unsigned int& hashVal) const
+findBucketElem(const void* const key, XMLSize_t& hashVal) const
{
// Hash the key
hashVal = fHash==0?XMLString::hash((const XMLCh*)key, fHashModulus, fMemoryManager) : fHash->getHashVal(key, fHashModulus, fMemoryManager);
@@ -597,7 +597,7 @@
template <class TVal> void RefHashTableOfEnumerator<TVal>::Reset()
{
- fCurHash = (unsigned int)-1;
+ fCurHash = (XMLSize_t)-1;
fCurElem = 0;
findNext();
}
Modified: xerces/c/trunk/src/xercesc/util/RefHashTableOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefHashTableOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefHashTableOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/RefHashTableOf.hpp Tue Jul 15 06:27:32 2008
@@ -78,13 +78,13 @@
// backwards compatability - default hasher is HashXMLCh
RefHashTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
// backwards compatability - default hasher is HashXMLCh
RefHashTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, const bool adoptElems
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -93,7 +93,7 @@
// may delete the hasher of a different hashtable if both use the same hasher.
RefHashTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, const bool adoptElems
, HashBase* hashBase
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
@@ -119,8 +119,8 @@
TVal* get(const void* const key);
const TVal* get(const void* const key) const;
MemoryManager* getMemoryManager() const;
- unsigned int getHashModulus() const;
- unsigned int getCount() const;
+ XMLSize_t getHashModulus() const;
+ XMLSize_t getCount() const;
// -----------------------------------------------------------------------
// Setters
@@ -150,9 +150,9 @@
// -----------------------------------------------------------------------
// Private methods
// -----------------------------------------------------------------------
- RefHashTableBucketElem<TVal>* findBucketElem(const void* const key, unsigned int& hashVal);
- const RefHashTableBucketElem<TVal>* findBucketElem(const void* const key, unsigned int& hashVal) const;
- void initialize(const unsigned int modulus);
+ RefHashTableBucketElem<TVal>* findBucketElem(const void* const key, XMLSize_t& hashVal);
+ const RefHashTableBucketElem<TVal>* findBucketElem(const void* const key, XMLSize_t& hashVal) const;
+ void initialize(const XMLSize_t modulus);
void rehash();
@@ -178,9 +178,9 @@
MemoryManager* fMemoryManager;
bool fAdoptedElems;
RefHashTableBucketElem<TVal>** fBucketList;
- unsigned int fHashModulus;
- unsigned int fInitialModulus;
- unsigned int fCount;
+ XMLSize_t fHashModulus;
+ XMLSize_t fInitialModulus;
+ XMLSize_t fCount;
HashBase* fHash;
};
@@ -246,7 +246,7 @@
// -----------------------------------------------------------------------
bool fAdopted;
RefHashTableBucketElem<TVal>* fCurElem;
- unsigned int fCurHash;
+ XMLSize_t fCurHash;
RefHashTableOf<TVal>* fToEnum;
MemoryManager* const fMemoryManager;
};
Modified: xerces/c/trunk/src/xercesc/util/RefStackOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefStackOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefStackOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/RefStackOf.c Tue Jul 15 06:27:32 2008
@@ -33,7 +33,7 @@
// RefStackOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem>
-RefStackOf<TElem>::RefStackOf(const unsigned int initElems,
+RefStackOf<TElem>::RefStackOf(const XMLSize_t initElems,
const bool adoptElems,
MemoryManager* const manager) :
@@ -50,14 +50,14 @@
// RefStackOf: Element management methods
// ---------------------------------------------------------------------------
template <class TElem> const TElem* RefStackOf<TElem>::
-elementAt(const unsigned int index) const
+elementAt(const XMLSize_t index) const
{
if (index >= fVector.size())
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Stack_BadIndex, fVector.getMemoryManager());
return fVector.elementAt(index);
}
-template <class TElem> TElem* RefStackOf<TElem>::popAt(const unsigned int index)
+template <class TElem> TElem* RefStackOf<TElem>::popAt(const XMLSize_t index)
{
if (index >= fVector.size())
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Stack_BadIndex, fVector.getMemoryManager());
@@ -73,7 +73,7 @@
template <class TElem> const TElem* RefStackOf<TElem>::peek() const
{
- const int curSize = fVector.size();
+ const XMLSize_t curSize = fVector.size();
if (curSize == 0)
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
@@ -82,7 +82,7 @@
template <class TElem> TElem* RefStackOf<TElem>::pop()
{
- const int curSize = fVector.size();
+ const XMLSize_t curSize = fVector.size();
if (curSize == 0)
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
@@ -104,12 +104,12 @@
return (fVector.size() == 0);
}
-template <class TElem> unsigned int RefStackOf<TElem>::curCapacity()
+template <class TElem> XMLSize_t RefStackOf<TElem>::curCapacity()
{
return fVector.curCapacity();
}
-template <class TElem> unsigned int RefStackOf<TElem>::size()
+template <class TElem> XMLSize_t RefStackOf<TElem>::size()
{
return fVector.size();
}
Modified: xerces/c/trunk/src/xercesc/util/RefStackOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefStackOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefStackOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/RefStackOf.hpp Tue Jul 15 06:27:32 2008
@@ -40,7 +40,7 @@
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- RefStackOf(const unsigned int initElems,
+ RefStackOf(const XMLSize_t initElems,
const bool adoptElems = true,
MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
~RefStackOf();
@@ -49,8 +49,8 @@
// -----------------------------------------------------------------------
// Element management methods
// -----------------------------------------------------------------------
- const TElem* elementAt(const unsigned int index) const;
- TElem* popAt(const unsigned int index);
+ const TElem* elementAt(const XMLSize_t index) const;
+ TElem* popAt(const XMLSize_t index);
void push(TElem* const toPush);
const TElem* peek() const;
TElem* pop();
@@ -61,8 +61,8 @@
// Getter methods
// -----------------------------------------------------------------------
bool empty();
- unsigned int curCapacity();
- unsigned int size();
+ XMLSize_t curCapacity();
+ XMLSize_t size();
private :
@@ -138,7 +138,7 @@
// inside of it.
// -----------------------------------------------------------------------
bool fAdopted;
- unsigned int fCurIndex;
+ XMLSize_t fCurIndex;
RefVectorOf<TElem>* fVector;
RefStackOf<TElem>* fToEnum;
};
Modified: xerces/c/trunk/src/xercesc/util/RefVectorOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefVectorOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefVectorOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/RefVectorOf.c Tue Jul 15 06:27:32 2008
@@ -33,7 +33,7 @@
// RefVectorOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem>
-RefVectorOf<TElem>::RefVectorOf(const unsigned int maxElems,
+RefVectorOf<TElem>::RefVectorOf(const XMLSize_t maxElems,
const bool adoptElems,
MemoryManager* const manager)
: BaseRefVectorOf<TElem>(maxElems, adoptElems, manager)
@@ -44,8 +44,8 @@
{
if (this->fAdoptedElems)
{
- for (unsigned int index = 0; index < this->fCurCount; index++)
- delete this->fElemList[index];
+ for (XMLSize_t index = 0; index < this->fCurCount; index++)
+ delete this->fElemList[index];
}
this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
}
Modified: xerces/c/trunk/src/xercesc/util/RefVectorOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/RefVectorOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/RefVectorOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/RefVectorOf.hpp Tue Jul 15 06:27:32 2008
@@ -36,7 +36,7 @@
// -----------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------
- RefVectorOf(const unsigned int maxElems,
+ RefVectorOf(const XMLSize_t maxElems,
const bool adoptElems = true,
MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
Modified: xerces/c/trunk/src/xercesc/util/ValueArrayOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueArrayOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueArrayOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/ValueArrayOf.c Tue Jul 15 06:27:32 2008
@@ -34,7 +34,7 @@
// ValueArrayOf: Contructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem>
-ValueArrayOf<TElem>::ValueArrayOf(const unsigned int size,
+ValueArrayOf<TElem>::ValueArrayOf(const XMLSize_t size,
MemoryManager* const manager) :
fSize(size)
@@ -46,7 +46,7 @@
template <class TElem>
ValueArrayOf<TElem>::ValueArrayOf( const TElem* values
- , const unsigned int size
+ , const XMLSize_t size
, MemoryManager* const manager) :
fSize(size)
@@ -54,7 +54,7 @@
, fMemoryManager(manager)
{
fArray = (TElem*) fMemoryManager->allocate(fSize * sizeof(TElem)); //new TElem[fSize];
- for (unsigned int index = 0; index < fSize; index++)
+ for (XMLSize_t index = 0; index < fSize; index++)
fArray[index] = values[index];
}
@@ -66,7 +66,7 @@
, fMemoryManager(source.fMemoryManager)
{
fArray = (TElem*) fMemoryManager->allocate(fSize * sizeof(TElem)); //new TElem[fSize];
- for (unsigned int index = 0; index < fSize; index++)
+ for (XMLSize_t index = 0; index < fSize; index++)
fArray[index] = source.fArray[index];
}
@@ -80,7 +80,7 @@
// ValueArrayOf: Public operators
// ---------------------------------------------------------------------------
template <class TElem> TElem& ValueArrayOf<TElem>::
-operator[](const unsigned int index)
+operator[](const XMLSize_t index)
{
if (index >= fSize)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Array_BadIndex, fMemoryManager);
@@ -88,7 +88,7 @@
}
template <class TElem> const TElem& ValueArrayOf<TElem>::
-operator[](const unsigned int index) const
+operator[](const XMLSize_t index) const
{
if (index >= fSize)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Array_BadIndex, fMemoryManager);
@@ -110,7 +110,7 @@
}
// Copy over the source elements
- for (unsigned int index = 0; index < fSize; index++)
+ for (XMLSize_t index = 0; index < fSize; index++)
fArray[index] = toAssign.fArray[index];
return *this;
@@ -125,7 +125,7 @@
if (fSize != toCompare.fSize)
return false;
- for (unsigned int index = 0; index < fSize; index++)
+ for (XMLSize_t index = 0; index < fSize; index++)
{
if (fArray[index] != toCompare.fArray[index])
return false;
@@ -144,17 +144,17 @@
// ---------------------------------------------------------------------------
// ValueArrayOf: Copy operations
// ---------------------------------------------------------------------------
-template <class TElem> unsigned int ValueArrayOf<TElem>::
+template <class TElem> XMLSize_t ValueArrayOf<TElem>::
copyFrom(const ValueArrayOf<TElem>& srcArray)
{
//
// Copy over as many of the source elements as will fit into
// this array.
//
- const unsigned int count = fSize < srcArray.fSize ?
+ const XMLSize_t count = fSize < srcArray.fSize ?
fSize : srcArray.fSize;
- for (unsigned int index = 0; index < count; index++)
+ for (XMLSize_t index = 0; index < count; index++)
fArray[index] = srcArray.fArray[index];
return count;
@@ -164,7 +164,7 @@
// ---------------------------------------------------------------------------
// ValueArrayOf: Getter methods
// ---------------------------------------------------------------------------
-template <class TElem> unsigned int ValueArrayOf<TElem>::
+template <class TElem> XMLSize_t ValueArrayOf<TElem>::
length() const
{
return fSize;
@@ -181,7 +181,7 @@
// ValueArrayOf: Miscellaneous methods
// ---------------------------------------------------------------------------
template <class TElem> void ValueArrayOf<TElem>::
-resize(const unsigned int newSize)
+resize(const XMLSize_t newSize)
{
if (newSize == fSize)
return;
@@ -196,7 +196,7 @@
); //new TElem[newSize];
// Copy the existing values
- unsigned int index = 0;
+ XMLSize_t index = 0;
for (; index < fSize; index++)
newArray[index] = fArray[index];
Modified: xerces/c/trunk/src/xercesc/util/ValueArrayOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueArrayOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueArrayOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/ValueArrayOf.hpp Tue Jul 15 06:27:32 2008
@@ -38,13 +38,13 @@
// -----------------------------------------------------------------------
ValueArrayOf
(
- const unsigned int size
+ const XMLSize_t size
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
ValueArrayOf
(
const TElem* values
- , const unsigned int size
+ , const XMLSize_t size
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
ValueArrayOf(const ValueArrayOf<TElem>& source);
@@ -54,8 +54,8 @@
// -----------------------------------------------------------------------
// Public operators
// -----------------------------------------------------------------------
- TElem& operator[](const unsigned int index);
- const TElem& operator[](const unsigned int index) const;
+ TElem& operator[](const XMLSize_t index);
+ const TElem& operator[](const XMLSize_t index) const;
ValueArrayOf<TElem>& operator=(const ValueArrayOf<TElem>& toAssign);
bool operator==(const ValueArrayOf<TElem>& toCompare) const;
bool operator!=(const ValueArrayOf<TElem>& toCompare) const;
@@ -64,27 +64,27 @@
// -----------------------------------------------------------------------
// Copy operations
// -----------------------------------------------------------------------
- unsigned int copyFrom(const ValueArrayOf<TElem>& srcArray);
+ XMLSize_t copyFrom(const ValueArrayOf<TElem>& srcArray);
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
- unsigned int length() const;
+ XMLSize_t length() const;
TElem* rawData() const;
// -----------------------------------------------------------------------
// Miscellaneous methods
// -----------------------------------------------------------------------
- void resize(const unsigned int newSize);
+ void resize(const XMLSize_t newSize);
private :
// -----------------------------------------------------------------------
// Data members
// -----------------------------------------------------------------------
- unsigned int fSize;
+ XMLSize_t fSize;
TElem* fArray;
MemoryManager* fMemoryManager;
};
@@ -137,7 +137,7 @@
// The value array being enumerated.
// -----------------------------------------------------------------------
bool fAdopted;
- unsigned int fCurIndex;
+ XMLSize_t fCurIndex;
ValueArrayOf<TElem>* fToEnum;
};
Modified: xerces/c/trunk/src/xercesc/util/ValueHashTableOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueHashTableOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueHashTableOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/ValueHashTableOf.c Tue Jul 15 06:27:32 2008
@@ -28,6 +28,7 @@
#endif
#include <xercesc/util/NullPointerException.hpp>
+#include <xercesc/util/Janitor.hpp>
#include <assert.h>
#include <new>
@@ -37,12 +38,14 @@
// ValueHashTableOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TVal>
-ValueHashTableOf<TVal>::ValueHashTableOf( const unsigned int modulus
+ValueHashTableOf<TVal>::ValueHashTableOf( const XMLSize_t modulus
, HashBase* hashBase
, MemoryManager* const manager)
: fMemoryManager(manager)
, fBucketList(0)
, fHashModulus(modulus)
+ , fInitialModulus(modulus)
+ , fCount(0)
, fHash(0)
{
initialize(modulus);
@@ -51,11 +54,13 @@
}
template <class TVal>
-ValueHashTableOf<TVal>::ValueHashTableOf( const unsigned int modulus
+ValueHashTableOf<TVal>::ValueHashTableOf( const XMLSize_t modulus
, MemoryManager* const manager)
: fMemoryManager(manager)
, fBucketList(0)
, fHashModulus(modulus)
+ , fInitialModulus(modulus)
+ , fCount(0)
, fHash(0)
{
initialize(modulus);
@@ -64,7 +69,7 @@
fHash = new (fMemoryManager) HashXMLCh();
}
-template <class TVal> void ValueHashTableOf<TVal>::initialize(const unsigned int modulus)
+template <class TVal> void ValueHashTableOf<TVal>::initialize(const XMLSize_t modulus)
{
if (modulus == 0)
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
@@ -92,19 +97,13 @@
// ---------------------------------------------------------------------------
template <class TVal> bool ValueHashTableOf<TVal>::isEmpty() const
{
- // Just check the bucket list for non-empty elements
- for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++)
- {
- if (fBucketList[buckInd] != 0)
- return false;
- }
- return true;
+ return fCount==0;
}
template <class TVal> bool ValueHashTableOf<TVal>::
containsKey(const void* const key) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
return (findIt != 0);
}
@@ -112,14 +111,17 @@
template <class TVal> void ValueHashTableOf<TVal>::
removeKey(const void* const key)
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
removeBucketElem(key, hashVal);
}
template <class TVal> void ValueHashTableOf<TVal>::removeAll()
{
+ if(isEmpty())
+ return;
+
// Clean up the buckets first
- for (unsigned int buckInd = 0; buckInd < fHashModulus; buckInd++)
+ for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
{
// Get the bucket list head for this entry
ValueHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
@@ -139,6 +141,7 @@
// Clean out this entry
fBucketList[buckInd] = 0;
}
+ fCount = 0;
}
@@ -147,7 +150,7 @@
// ---------------------------------------------------------------------------
template <class TVal> TVal& ValueHashTableOf<TVal>::get(const void* const key, MemoryManager* const manager)
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists, manager);
@@ -158,7 +161,7 @@
template <class TVal> const TVal& ValueHashTableOf<TVal>::
get(const void* const key) const
{
- unsigned int hashVal;
+ XMLSize_t hashVal;
const ValueHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
if (!findIt)
ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::HshTbl_NoSuchKeyExists, fMemoryManager);
@@ -172,8 +175,15 @@
// ---------------------------------------------------------------------------
template <class TVal> void ValueHashTableOf<TVal>::put(void* key, const TVal& 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
- unsigned int hashVal;
+ XMLSize_t hashVal;
ValueHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
//
@@ -191,6 +201,7 @@
new (fMemoryManager->allocate(sizeof(ValueHashTableBucketElem<TVal>)))
ValueHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
fBucketList[hashVal] = newBucket;
+ fCount++;
}
}
@@ -199,8 +210,61 @@
// ---------------------------------------------------------------------------
// ValueHashTableOf: Private methods
// ---------------------------------------------------------------------------
+template <class TVal> void ValueHashTableOf<TVal>::rehash()
+{
+ const XMLSize_t newMod = (fHashModulus * 2) + 1;
+
+ ValueHashTableBucketElem<TVal>** newBucketList =
+ (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
+ (
+ newMod * sizeof(ValueHashTableBucketElem<TVal>*)
+ );//new RefHashTableBucketElem<TVal>*[newMod];
+
+ // Make sure the new bucket list is destroyed if an
+ // exception is thrown.
+ ArrayJanitor<ValueHashTableBucketElem<TVal>*> guard(newBucketList, fMemoryManager);
+
+ memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
+
+
+ // Rehash all existing entries.
+ for (XMLSize_t index = 0; index < fHashModulus; index++)
+ {
+ // Get the bucket list head for this entry
+ ValueHashTableBucketElem<TVal>* curElem = fBucketList[index];
+
+ while (curElem)
+ {
+ // Save the next element before we detach this one
+ ValueHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
+
+ const XMLSize_t hashVal = fHash->getHashVal(curElem->fKey, newMod, fMemoryManager);
+ assert(hashVal < newMod);
+
+ ValueHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
+
+ // Insert at the start of this bucket's list.
+ curElem->fNext = newHeadElem;
+ newBucketList[hashVal] = curElem;
+
+ curElem = nextElem;
+ }
+ }
+
+ ValueHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
+
+ // Everything is OK at this point, so update the
+ // member variables.
+ fBucketList = guard.release();
+ fHashModulus = newMod;
+
+ // Delete the old bucket list.
+ fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
+
+}
+
template <class TVal> ValueHashTableBucketElem<TVal>* ValueHashTableOf<TVal>::
-findBucketElem(const void* const key, unsigned int& hashVal)
+findBucketElem(const void* const key, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHash->getHashVal(key, fHashModulus, fMemoryManager);
@@ -219,7 +283,7 @@
}
template <class TVal> const ValueHashTableBucketElem<TVal>* ValueHashTableOf<TVal>::
-findBucketElem(const void* const key, unsigned int& hashVal) const
+findBucketElem(const void* const key, XMLSize_t& hashVal) const
{
// Hash the key
hashVal = fHash->getHashVal(key, fHashModulus, fMemoryManager);
@@ -239,7 +303,7 @@
template <class TVal> void ValueHashTableOf<TVal>::
-removeBucketElem(const void* const key, unsigned int& hashVal)
+removeBucketElem(const void* const key, XMLSize_t& hashVal)
{
// Hash the key
hashVal = fHash->getHashVal(key, fHashModulus);
@@ -273,6 +337,8 @@
// curElem->~ValueHashTableBucketElem();
fMemoryManager->deallocate(curElem);
+ fCount--;
+
return;
}
@@ -295,7 +361,7 @@
ValueHashTableOfEnumerator(ValueHashTableOf<TVal>* const toEnum
, const bool adopt
, MemoryManager* const manager)
- : fAdopted(adopt), fCurElem(0), fCurHash((unsigned int)-1), fToEnum(toEnum), fMemoryManager(manager)
+ : fAdopted(adopt), fCurElem(0), fCurHash((XMLSize_t)-1), fToEnum(toEnum), fMemoryManager(manager)
{
if (!toEnum)
ThrowXMLwithMemMgr(NullPointerException, XMLExcepts::CPtr_PointerIsZero, manager);
@@ -366,7 +432,7 @@
template <class TVal> void ValueHashTableOfEnumerator<TVal>::Reset()
{
- fCurHash = (unsigned int)-1;
+ fCurHash = (XMLSize_t)-1;
fCurElem = 0;
findNext();
}
@@ -392,16 +458,14 @@
//
if (!fCurElem)
{
- fCurHash++;
- if (fCurHash == fToEnum->fHashModulus)
+ if (++fCurHash == fToEnum->fHashModulus)
return;
// Else find the next non-empty bucket
while (fToEnum->fBucketList[fCurHash]==0)
{
// Bump to the next hash value. If we max out return
- fCurHash++;
- if (fCurHash == fToEnum->fHashModulus)
+ if (++fCurHash == fToEnum->fHashModulus)
return;
}
fCurElem = fToEnum->fBucketList[fCurHash];
Modified: xerces/c/trunk/src/xercesc/util/ValueHashTableOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueHashTableOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueHashTableOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/ValueHashTableOf.hpp Tue Jul 15 06:27:32 2008
@@ -76,7 +76,7 @@
// backwards compatability - default hasher is HashXMLCh
ValueHashTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
// if a hash function is passed in, it will be deleted when the hashtable is deleted.
@@ -84,7 +84,7 @@
// may delete the hasher of a different hashtable if both use the same hasher.
ValueHashTableOf
(
- const unsigned int modulus
+ const XMLSize_t modulus
, HashBase* hashBase
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -129,10 +129,11 @@
// -----------------------------------------------------------------------
// Private methods
// -----------------------------------------------------------------------
- ValueHashTableBucketElem<TVal>* findBucketElem(const void* const key, unsigned int& hashVal);
- const ValueHashTableBucketElem<TVal>* findBucketElem(const void* const key, unsigned int& hashVal) const;
- void removeBucketElem(const void* const key, unsigned int& hashVal);
- void initialize(const unsigned int modulus);
+ ValueHashTableBucketElem<TVal>* findBucketElem(const void* const key, XMLSize_t& hashVal);
+ const ValueHashTableBucketElem<TVal>* findBucketElem(const void* const key, XMLSize_t& hashVal) const;
+ void removeBucketElem(const void* const key, XMLSize_t& hashVal);
+ void initialize(const XMLSize_t modulus);
+ void rehash();
// -----------------------------------------------------------------------
@@ -151,7 +152,9 @@
// -----------------------------------------------------------------------
MemoryManager* fMemoryManager;
ValueHashTableBucketElem<TVal>** fBucketList;
- unsigned int fHashModulus;
+ XMLSize_t fHashModulus;
+ XMLSize_t fInitialModulus;
+ XMLSize_t fCount;
HashBase* fHash;
};
@@ -219,7 +222,7 @@
// -----------------------------------------------------------------------
bool fAdopted;
ValueHashTableBucketElem<TVal>* fCurElem;
- unsigned int fCurHash;
+ XMLSize_t fCurHash;
ValueHashTableOf<TVal>* fToEnum;
MemoryManager* const fMemoryManager;
};
Modified: xerces/c/trunk/src/xercesc/util/ValueStackOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueStackOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueStackOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/ValueStackOf.c Tue Jul 15 06:27:32 2008
@@ -34,7 +34,7 @@
// ValueStackOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem>
-ValueStackOf<TElem>::ValueStackOf(const unsigned int fInitCapacity,
+ValueStackOf<TElem>::ValueStackOf(const XMLSize_t fInitCapacity,
MemoryManager* const manager,
const bool toCallDestructor) :
@@ -57,7 +57,7 @@
template <class TElem> const TElem& ValueStackOf<TElem>::peek() const
{
- const unsigned int curSize = fVector.size();
+ const XMLSize_t curSize = fVector.size();
if (curSize == 0)
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
@@ -66,7 +66,7 @@
template <class TElem> TElem ValueStackOf<TElem>::pop()
{
- const unsigned int curSize = fVector.size();
+ const XMLSize_t curSize = fVector.size();
if (curSize == 0)
ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
@@ -89,12 +89,12 @@
return (fVector.size() == 0);
}
-template <class TElem> unsigned int ValueStackOf<TElem>::curCapacity()
+template <class TElem> XMLSize_t ValueStackOf<TElem>::curCapacity()
{
return fVector.curCapacity();
}
-template <class TElem> unsigned int ValueStackOf<TElem>::size()
+template <class TElem> XMLSize_t ValueStackOf<TElem>::size()
{
return fVector.size();
}
Modified: xerces/c/trunk/src/xercesc/util/ValueStackOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueStackOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueStackOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/ValueStackOf.hpp Tue Jul 15 06:27:32 2008
@@ -42,7 +42,7 @@
// -----------------------------------------------------------------------
ValueStackOf
(
- const unsigned int fInitCapacity
+ const XMLSize_t fInitCapacity
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
, const bool toCallDestructor = false
);
@@ -62,8 +62,8 @@
// Getter methods
// -----------------------------------------------------------------------
bool empty();
- unsigned int curCapacity();
- unsigned int size();
+ XMLSize_t curCapacity();
+ XMLSize_t size();
private :
@@ -141,7 +141,7 @@
// inside of it.
// -----------------------------------------------------------------------
bool fAdopted;
- unsigned int fCurIndex;
+ XMLSize_t fCurIndex;
ValueVectorOf<TElem>* fVector;
ValueStackOf<TElem>* fToEnum;
};
Modified: xerces/c/trunk/src/xercesc/util/ValueVectorOf.c
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueVectorOf.c?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueVectorOf.c (original)
+++ xerces/c/trunk/src/xercesc/util/ValueVectorOf.c Tue Jul 15 06:27:32 2008
@@ -34,7 +34,7 @@
// ValueVectorOf: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem>
-ValueVectorOf<TElem>::ValueVectorOf(const unsigned int maxElems,
+ValueVectorOf<TElem>::ValueVectorOf(const XMLSize_t maxElems,
MemoryManager* const manager,
const bool toCallDestructor) :
@@ -67,15 +67,15 @@
); //new TElem[fMaxCount];
memset(fElemList, 0, fMaxCount * sizeof(TElem));
- for (unsigned int index = 0; index < fCurCount; index++)
+ for (XMLSize_t index = 0; index < fCurCount; index++)
fElemList[index] = toCopy.fElemList[index];
}
template <class TElem> ValueVectorOf<TElem>::~ValueVectorOf()
{
if (fCallDestructor) {
- for (int index= fMaxCount - 1; index >= 0; index--)
- fElemList[index].~TElem();
+ for (XMLSize_t index=fMaxCount; index > 0; index--)
+ fElemList[index-1].~TElem();
}
fMemoryManager->deallocate(fElemList); //delete [] fElemList;
}
@@ -103,7 +103,7 @@
}
fCurCount = toAssign.fCurCount;
- for (unsigned int index = 0; index < fCurCount; index++)
+ for (XMLSize_t index = 0; index < fCurCount; index++)
fElemList[index] = toAssign.fElemList[index];
return *this;
@@ -120,7 +120,7 @@
}
template <class TElem> void ValueVectorOf<TElem>::
-setElementAt(const TElem& toSet, const unsigned int setAt)
+setElementAt(const TElem& toSet, const XMLSize_t setAt)
{
if (setAt >= fCurCount)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
@@ -128,7 +128,7 @@
}
template <class TElem> void ValueVectorOf<TElem>::
-insertElementAt(const TElem& toInsert, const unsigned int insertAt)
+insertElementAt(const TElem& toInsert, const XMLSize_t insertAt)
{
if (insertAt == fCurCount)
{
@@ -141,7 +141,7 @@
// Make room for the newbie
ensureExtraCapacity(1);
- for (unsigned int index = fCurCount; index > insertAt; index--)
+ for (XMLSize_t index = fCurCount; index > insertAt; index--)
fElemList[index] = fElemList[index-1];
// And stick it in and bump the count
@@ -150,13 +150,13 @@
}
template <class TElem> void ValueVectorOf<TElem>::
-removeElementAt(const unsigned int removeAt)
+removeElementAt(const XMLSize_t removeAt)
{
if (removeAt >= fCurCount)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
// Copy down every element above remove point
- for (unsigned int index = removeAt; index < fCurCount-1; index++)
+ for (XMLSize_t index = removeAt; index < fCurCount-1; index++)
fElemList[index] = fElemList[index+1];
// And bump down count
@@ -170,9 +170,9 @@
template <class TElem>
bool ValueVectorOf<TElem>::containsElement(const TElem& toCheck,
- const unsigned int startIndex) {
+ const XMLSize_t startIndex) {
- for (unsigned int i = startIndex; i < fCurCount; i++) {
+ for (XMLSize_t i = startIndex; i < fCurCount; i++) {
if (fElemList[i] == toCheck) {
return true;
}
@@ -186,7 +186,7 @@
// ValueVectorOf: Getter methods
// ---------------------------------------------------------------------------
template <class TElem> const TElem& ValueVectorOf<TElem>::
-elementAt(const unsigned int getAt) const
+elementAt(const XMLSize_t getAt) const
{
if (getAt >= fCurCount)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
@@ -194,19 +194,19 @@
}
template <class TElem> TElem& ValueVectorOf<TElem>::
-elementAt(const unsigned int getAt)
+elementAt(const XMLSize_t getAt)
{
if (getAt >= fCurCount)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
return fElemList[getAt];
}
-template <class TElem> unsigned int ValueVectorOf<TElem>::curCapacity() const
+template <class TElem> XMLSize_t ValueVectorOf<TElem>::curCapacity() const
{
return fMaxCount;
}
-template <class TElem> unsigned int ValueVectorOf<TElem>::size() const
+template <class TElem> XMLSize_t ValueVectorOf<TElem>::size() const
{
return fCurCount;
}
@@ -221,14 +221,14 @@
// ValueVectorOf: Miscellaneous
// ---------------------------------------------------------------------------
template <class TElem> void ValueVectorOf<TElem>::
-ensureExtraCapacity(const unsigned int length)
+ensureExtraCapacity(const XMLSize_t length)
{
- unsigned int newMax = fCurCount + length;
+ XMLSize_t newMax = fCurCount + length;
if (newMax > fMaxCount)
{
// Avoid too many reallocations by expanding by a percentage
- unsigned int minNewMax = (unsigned int)((double)fCurCount * 1.25);
+ XMLSize_t minNewMax = (XMLSize_t)((double)fCurCount * 1.25);
if (newMax < minNewMax)
newMax = minNewMax;
@@ -236,7 +236,7 @@
(
newMax * sizeof(TElem)
); //new TElem[newMax];
- for (unsigned int index = 0; index < fCurCount; index++)
+ for (XMLSize_t index = 0; index < fCurCount; index++)
newList[index] = fElemList[index];
fMemoryManager->deallocate(fElemList); //delete [] fElemList;
Modified: xerces/c/trunk/src/xercesc/util/ValueVectorOf.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/ValueVectorOf.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/ValueVectorOf.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/ValueVectorOf.hpp Tue Jul 15 06:27:32 2008
@@ -37,7 +37,7 @@
// -----------------------------------------------------------------------
ValueVectorOf
(
- const unsigned int maxElems
+ const XMLSize_t maxElems
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
, const bool toCallDestructor = false
);
@@ -55,27 +55,27 @@
// Element management
// -----------------------------------------------------------------------
void addElement(const TElem& toAdd);
- void setElementAt(const TElem& toSet, const unsigned int setAt);
- void insertElementAt(const TElem& toInsert, const unsigned int insertAt);
- void removeElementAt(const unsigned int removeAt);
+ void setElementAt(const TElem& toSet, const XMLSize_t setAt);
+ void insertElementAt(const TElem& toInsert, const XMLSize_t insertAt);
+ void removeElementAt(const XMLSize_t removeAt);
void removeAllElements();
- bool containsElement(const TElem& toCheck, const unsigned int startIndex = 0);
+ bool containsElement(const TElem& toCheck, const XMLSize_t startIndex = 0);
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
- const TElem& elementAt(const unsigned int getAt) const;
- TElem& elementAt(const unsigned int getAt);
- unsigned int curCapacity() const;
- unsigned int size() const;
+ const TElem& elementAt(const XMLSize_t getAt) const;
+ TElem& elementAt(const XMLSize_t getAt);
+ XMLSize_t curCapacity() const;
+ XMLSize_t size() const;
MemoryManager* getMemoryManager() const;
// -----------------------------------------------------------------------
// Miscellaneous
// -----------------------------------------------------------------------
- void ensureExtraCapacity(const unsigned int length);
+ void ensureExtraCapacity(const XMLSize_t length);
const TElem* rawData() const;
@@ -95,8 +95,8 @@
// size.
// -----------------------------------------------------------------------
bool fCallDestructor;
- unsigned int fCurCount;
- unsigned int fMaxCount;
+ XMLSize_t fCurCount;
+ XMLSize_t fMaxCount;
TElem* fElemList;
MemoryManager* fMemoryManager;
};
@@ -149,7 +149,7 @@
// The value vector being enumerated.
// -----------------------------------------------------------------------
bool fAdopted;
- unsigned int fCurIndex;
+ XMLSize_t fCurIndex;
ValueVectorOf<TElem>* fToEnum;
};
Modified: xerces/c/trunk/src/xercesc/util/XMLChar.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/XMLChar.cpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/XMLChar.cpp (original)
+++ xerces/c/trunk/src/xercesc/util/XMLChar.cpp Tue Jul 15 06:27:32 2008
@@ -164,26 +164,21 @@
{
if (count == 0)
return false;
-
- XMLSize_t length = count;
- int colonPos = XMLString::indexOf(toCheck, chColon);
- if ((colonPos == 0) || // ":abcd"
- (colonPos == ((int)length)-1)) // "abcd:"
+ XMLSize_t colonPos=0;
+ // don't use XMLString::indexOf, we must stop after 'count' chars
+ while(colonPos<count && toCheck[colonPos]!=chColon)
+ colonPos++;
+ if ((colonPos == 0) || // ":abcd"
+ (colonPos+1 == count)) // "abcd:"
return false;
- //
- // prefix
- //
- if (colonPos != -1)
+ if(colonPos != count)
{
- if (isValidNCName(toCheck, colonPos) == false)
- return false;
+ // prefix & local part
+ return isValidNCName(toCheck, colonPos) &&
+ isValidNCName(toCheck+colonPos+1, count-colonPos-1);
}
-
- //
- // LocalPart
- //
- return isValidNCName(toCheck+colonPos+1, length-colonPos-1);
+ return isValidNCName(toCheck, count);
}
//
Modified: xerces/c/trunk/src/xercesc/util/XMLString.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/XMLString.cpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/XMLString.cpp (original)
+++ xerces/c/trunk/src/xercesc/util/XMLString.cpp Tue Jul 15 06:27:32 2008
@@ -435,19 +435,19 @@
}
-unsigned int XMLString::hash( const char* const tohash
- , const unsigned int hashModulus
- , MemoryManager* const)
+XMLSize_t XMLString::hash( const char* const tohash
+ , const XMLSize_t hashModulus
+ , MemoryManager* const)
{
assert(hashModulus);
- unsigned int hashVal = 0;
+ XMLSize_t hashVal = 0;
if (tohash) {
const char* curCh = tohash;
while (*curCh)
{
- unsigned int top = hashVal >> 24;
- hashVal += (hashVal * 37) + top + (unsigned int)(*curCh);
+ XMLSize_t top = hashVal >> 24;
+ hashVal += (hashVal * 37) + top + (XMLSize_t)(*curCh);
curCh++;
}
}
@@ -1404,24 +1404,21 @@
}
-unsigned int XMLString::hashN( const XMLCh* const tohash
- , const XMLSize_t n
- , const unsigned int hashModulus
- , MemoryManager* const)
+XMLSize_t XMLString::hashN( const XMLCh* const tohash
+ , const XMLSize_t n
+ , const XMLSize_t hashModulus
+ , MemoryManager* const)
{
assert(hashModulus);
- unsigned int hashVal = 0;
- if (tohash) {
- const XMLCh* curCh = tohash;
- int i = (int)n;
- while (i--)
- {
- unsigned int top = hashVal >> 24;
- hashVal += (hashVal * 37) + top + (unsigned int)(*curCh);
- curCh++;
- }
- }
+ if (tohash == 0 || *tohash == 0)
+ return 0;
+
+ const XMLCh* curCh = tohash;
+ XMLSize_t hashVal = (XMLSize_t)(*curCh++);
+
+ for(XMLSize_t i=0;i<n;i++)
+ hashVal = (hashVal * 38) + (hashVal >> 24) + (XMLSize_t)(*curCh++);
// Divide by modulus
return hashVal % hashModulus;
Modified: xerces/c/trunk/src/xercesc/util/XMLString.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/XMLString.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/XMLString.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/XMLString.hpp Tue Jul 15 06:27:32 2008
@@ -415,10 +415,10 @@
* @param manager The MemoryManager to use to allocate objects
* @return Returns the hash value
*/
- static unsigned int hash
+ static XMLSize_t hash
(
const char* const toHash
- , const unsigned int hashModulus
+ , const XMLSize_t hashModulus
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -429,10 +429,10 @@
* @param manager The MemoryManager to use to allocate objects
* @return Returns the hash value
*/
- static unsigned int hash
+ static XMLSize_t hash
(
const XMLCh* const toHash
- , const unsigned int hashModulus
+ , const XMLSize_t hashModulus
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -445,11 +445,11 @@
* @param manager The MemoryManager to use to allocate objects
* @return Returns the hash value
*/
- static unsigned int hashN
+ static XMLSize_t hashN
(
const XMLCh* const toHash
, const XMLSize_t numChars
- , const unsigned int hashModulus
+ , const XMLSize_t hashModulus
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
@@ -1571,8 +1571,8 @@
return XMLString::lastIndexOf(ch, toSearch, stringLen(toSearch));
}
-inline unsigned int XMLString::hash( const XMLCh* const tohash
- , const unsigned int hashModulus
+inline XMLSize_t XMLString::hash( const XMLCh* const tohash
+ , const XMLSize_t hashModulus
, MemoryManager* const)
{
assert(hashModulus);
@@ -1581,10 +1581,10 @@
return 0;
const XMLCh* curCh = tohash;
- unsigned int hashVal = (unsigned int)(*curCh++);
+ XMLSize_t hashVal = (XMLSize_t)(*curCh++);
while (*curCh)
- hashVal = (hashVal * 38) + (hashVal >> 24) + (unsigned int)(*curCh++);
+ hashVal = (hashVal * 38) + (hashVal >> 24) + (XMLSize_t)(*curCh++);
// Divide by modulus
return hashVal % hashModulus;
Modified: xerces/c/trunk/src/xercesc/util/regx/ClosureToken.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/ClosureToken.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/ClosureToken.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/ClosureToken.hpp Tue Jul 15 06:27:32 2008
@@ -41,10 +41,10 @@
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
- int size() const;
+ XMLSize_t size() const;
int getMin() const;
int getMax() const;
- Token* getChild(const int index) const;
+ Token* getChild(const XMLSize_t index) const;
// -----------------------------------------------------------------------
// Setter methods
@@ -71,7 +71,7 @@
// ---------------------------------------------------------------------------
// ClosureToken: getter methods
// ---------------------------------------------------------------------------
-inline int ClosureToken::size() const {
+inline XMLSize_t ClosureToken::size() const {
return 1;
}
@@ -87,7 +87,7 @@
return fMin;
}
-inline Token* ClosureToken::getChild(const int) const {
+inline Token* ClosureToken::getChild(const XMLSize_t) const {
return fChild;
}
Modified: xerces/c/trunk/src/xercesc/util/regx/ConcatToken.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/ConcatToken.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/ConcatToken.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/ConcatToken.hpp Tue Jul 15 06:27:32 2008
@@ -41,8 +41,8 @@
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
- Token* getChild(const int index) const;
- int size() const;
+ Token* getChild(const XMLSize_t index) const;
+ XMLSize_t size() const;
private:
// -----------------------------------------------------------------------
@@ -62,12 +62,12 @@
// ---------------------------------------------------------------------------
// StringToken: getter methods
// ---------------------------------------------------------------------------
-inline int ConcatToken::size() const {
+inline XMLSize_t ConcatToken::size() const {
return 2;
}
-inline Token* ConcatToken::getChild(const int index) const {
+inline Token* ConcatToken::getChild(const XMLSize_t index) const {
return index == 0 ? fChild1 : fChild2;
}
Modified: xerces/c/trunk/src/xercesc/util/regx/ConditionToken.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/ConditionToken.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/ConditionToken.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/ConditionToken.hpp Tue Jul 15 06:27:32 2008
@@ -42,9 +42,9 @@
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
- int size() const;
+ XMLSize_t size() const;
int getReferenceNo() const;
- Token* getChild(const int index) const;
+ Token* getChild(const XMLSize_t index) const;
Token* getConditionToken() const;
private:
@@ -67,7 +67,7 @@
// ---------------------------------------------------------------------------
// ConditionToken: getter methods
// ---------------------------------------------------------------------------
-inline int ConditionToken::size() const {
+inline XMLSize_t ConditionToken::size() const {
return fNoToken == 0 ? 1 : 2;
}
@@ -77,9 +77,9 @@
return fRefNo;
}
-inline Token* ConditionToken::getChild(const int index) const {
+inline Token* ConditionToken::getChild(const XMLSize_t index) const {
- if (index < 0 || index > 1)
+ if (index > 1)
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_InvalidChildIndex, fMemoryManager);
if (index == 0)
Modified: xerces/c/trunk/src/xercesc/util/regx/ModifierToken.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/ModifierToken.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/ModifierToken.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/ModifierToken.hpp Tue Jul 15 06:27:32 2008
@@ -41,10 +41,10 @@
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
- int size() const;
+ XMLSize_t size() const;
int getOptions() const;
int getOptionsMask() const;
- Token* getChild(const int index) const;
+ Token* getChild(const XMLSize_t index) const;
private:
// -----------------------------------------------------------------------
@@ -65,7 +65,7 @@
// ---------------------------------------------------------------------------
// ModifierToken: getter methods
// ---------------------------------------------------------------------------
-inline int ModifierToken::size() const {
+inline XMLSize_t ModifierToken::size() const {
return 1;
}
@@ -80,7 +80,7 @@
return fOptionsMask;
}
-inline Token* ModifierToken::getChild(const int) const {
+inline Token* ModifierToken::getChild(const XMLSize_t) const {
return fChild;
}
Modified: xerces/c/trunk/src/xercesc/util/regx/Op.cpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/Op.cpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/Op.cpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/Op.cpp Tue Jul 15 06:27:32 2008
@@ -40,7 +40,7 @@
// ---------------------------------------------------------------------------
// Op: Getter methods
// ---------------------------------------------------------------------------
-int Op::getSize() const {
+XMLSize_t Op::getSize() const {
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_NotSupported, fMemoryManager);
return 0; // for compilers that complain about no return value
@@ -64,7 +64,7 @@
return 0; // for compilers that complain about no return value
}
-const Op* Op::elementAt(int) const {
+const Op* Op::elementAt(XMLSize_t) const {
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_NotSupported, fMemoryManager);
return 0; // for compilers that complain about no return value
@@ -127,7 +127,7 @@
// ---------------------------------------------------------------------------
// UnionOp: Constructors and Destuctors
// ---------------------------------------------------------------------------
-UnionOp::UnionOp(const Op::opType type, const int size, MemoryManager* const manager)
+UnionOp::UnionOp(const Op::opType type, const XMLSize_t size, MemoryManager* const manager)
: Op(type, manager)
, fBranches(new (manager) RefVectorOf<Op> (size, false, manager)) {
@@ -136,12 +136,12 @@
// ---------------------------------------------------------------------------
// UnionOp: Getter/Setter methods
// ---------------------------------------------------------------------------
-int UnionOp::getSize() const {
+XMLSize_t UnionOp::getSize() const {
return fBranches->size();
}
-const Op* UnionOp::elementAt(int index) const {
+const Op* UnionOp::elementAt(XMLSize_t index) const {
return fBranches->elementAt(index);
}
Modified: xerces/c/trunk/src/xercesc/util/regx/Op.hpp
URL: http://svn.apache.org/viewvc/xerces/c/trunk/src/xercesc/util/regx/Op.hpp?rev=676911&r1=676910&r2=676911&view=diff
==============================================================================
--- xerces/c/trunk/src/xercesc/util/regx/Op.hpp (original)
+++ xerces/c/trunk/src/xercesc/util/regx/Op.hpp Tue Jul 15 06:27:32 2008
@@ -77,12 +77,12 @@
const Op* getNextOp() const;
virtual XMLInt32 getData() const;
virtual XMLInt32 getData2() const;
- virtual int getSize() const;
+ virtual XMLSize_t getSize() const;
virtual int getRefNo() const;
virtual const Op* getConditionFlow() const;
virtual const Op* getYesFlow() const;
virtual const Op* getNoFlow() const;
- virtual const Op* elementAt(int index) const;
+ virtual const Op* elementAt(XMLSize_t index) const;
virtual const Op* getChild() const;
virtual const Token* getToken() const;
virtual const XMLCh* getLiteral() const;
@@ -152,15 +152,15 @@
// -----------------------------------------------------------------------
// Public Constructors and Destructor
// -----------------------------------------------------------------------
- UnionOp(const opType type, const int size,
+ UnionOp(const opType type, const XMLSize_t size,
MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
~UnionOp() { delete fBranches; }
// -----------------------------------------------------------------------
// Getter functions
// -----------------------------------------------------------------------
- int getSize() const;
- const Op* elementAt(int index) const;
+ XMLSize_t getSize() const;
+ const Op* elementAt(XMLSize_t index) const;
// -----------------------------------------------------------------------
// Setter functions
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@xerces.apache.org
For additional commands, e-mail: commits-help@xerces.apache.org