OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0021212: Missing Hasher parmeter in current implementation of NCollection Map-s

Browse Source
This commit is contained in:
emv 2012-03-06 12:06:54 +04:00 committed by bugmaster
parent c3297e8285
commit 9991c9c2ca
8 changed files with 188 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/NCollection/FILES
View File

@ -79,3 +79,6 @@ NCollection_Comparator.hxx
NCollection_QuickSort.hxx NCollection_QuickSort.hxx
NCollection_Haft.h NCollection_Haft.h
NCollection_DefaultHasher.hxx

5
src/NCollection/NCollection_BaseList.hxx
View File

@ -49,6 +49,11 @@ class NCollection_BaseList
myCurrent = theList.myFirst; myCurrent = theList.myFirst;
myPrevious = NULL; myPrevious = NULL;
} }
// ******** Initialisation
void Initialize (const NCollection_BaseList& theList)
{
Init(theList);
}
// ******** More // ******** More
Standard_Boolean More (void) const Standard_Boolean More (void) const
{ return (myCurrent!=NULL); } { return (myCurrent!=NULL); }

31
src/NCollection/NCollection_DataMap.hxx
View File

@ -10,6 +10,8 @@
#include <NCollection_BaseMap.hxx> #include <NCollection_BaseMap.hxx>
#include <NCollection_TListNode.hxx> #include <NCollection_TListNode.hxx>
#include <NCollection_DefaultHasher.hxx>
#include <Standard_TypeMismatch.hxx> #include <Standard_TypeMismatch.hxx>
#include <Standard_NoSuchObject.hxx> #include <Standard_NoSuchObject.hxx>
@ -36,7 +38,11 @@
* can be done only if aKey was previously bound to * can be done only if aKey was previously bound to
* an item in the map. * an item in the map.
*/ */
template <class TheKeyType, class TheItemType> class NCollection_DataMap
template < class TheKeyType,
class TheItemType,
class Hasher = NCollection_DefaultHasher<TheKeyType> > class NCollection_DataMap
: public NCollection_BaseCollection<TheItemType>, : public NCollection_BaseCollection<TheItemType>,
public NCollection_BaseMap public NCollection_BaseMap
{ {
@ -179,7 +185,7 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
p = olddata[i]; p = olddata[i];
while (p) while (p)
{ {
k = HashCode(p->Key(),newBuck); k = Hasher::HashCode(p->Key(),newBuck);
q = (DataMapNode*) p->Next(); q = (DataMapNode*) p->Next();
p->Next() = newdata[k]; p->Next() = newdata[k];
newdata[k] = p; newdata[k] = p;
@ -201,11 +207,11 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
if (Resizable()) if (Resizable())
ReSize(Extent()); ReSize(Extent());
DataMapNode** data = (DataMapNode**)myData1; DataMapNode** data = (DataMapNode**)myData1;
Standard_Integer k = HashCode (theKey, NbBuckets()); Standard_Integer k = Hasher::HashCode (theKey, NbBuckets());
DataMapNode* p = data[k]; DataMapNode* p = data[k];
while (p) while (p)
{ {
if (IsEqual(p->Key(), theKey)) if (Hasher::IsEqual(p->Key(), theKey))
{ {
p->ChangeValue() = theItem; p->ChangeValue() = theItem;
return Standard_False; return Standard_False;
@ -223,10 +229,10 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
DataMapNode** data = (DataMapNode**) myData1; DataMapNode** data = (DataMapNode**) myData1;
DataMapNode* p = data[HashCode(K,NbBuckets())]; DataMapNode* p = data[Hasher::HashCode(K,NbBuckets())];
while (p) while (p)
{ {
if (IsEqual(p->Key(),K)) if (Hasher::IsEqual(p->Key(),K))
return Standard_True; return Standard_True;
p = (DataMapNode *) p->Next(); p = (DataMapNode *) p->Next();
} }
@ -239,12 +245,12 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
DataMapNode** data = (DataMapNode**) myData1; DataMapNode** data = (DataMapNode**) myData1;
Standard_Integer k = HashCode(K,NbBuckets()); Standard_Integer k = Hasher::HashCode(K,NbBuckets());
DataMapNode* p = data[k]; DataMapNode* p = data[k];
DataMapNode* q = NULL; DataMapNode* q = NULL;
while (p) while (p)
{ {
if (IsEqual(p->Key(),K)) if (Hasher::IsEqual(p->Key(),K))
{ {
Decrement(); Decrement();
if (q) if (q)
@ -268,10 +274,10 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
if (IsEmpty()) if (IsEmpty())
Standard_NoSuchObject::Raise ("NCollection_DataMap::Find"); Standard_NoSuchObject::Raise ("NCollection_DataMap::Find");
#endif #endif
DataMapNode* p = (DataMapNode*) myData1[HashCode(theKey,NbBuckets())]; DataMapNode* p = (DataMapNode*) myData1[Hasher::HashCode(theKey,NbBuckets())];
while (p) while (p)
{ {
if (IsEqual(p->Key(),theKey)) if (Hasher::IsEqual(p->Key(),theKey))
return p->Value(); return p->Value();
p = (DataMapNode*) p->Next(); p = (DataMapNode*) p->Next();
} }
@ -290,10 +296,10 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
if (IsEmpty()) if (IsEmpty())
Standard_NoSuchObject::Raise ("NCollection_DataMap::Find"); Standard_NoSuchObject::Raise ("NCollection_DataMap::Find");
#endif #endif
DataMapNode* p = (DataMapNode*) myData1[HashCode(theKey,NbBuckets())]; DataMapNode* p = (DataMapNode*) myData1[Hasher::HashCode(theKey,NbBuckets())];
while (p) while (p)
{ {
if (IsEqual(p->Key(),theKey)) if (Hasher::IsEqual(p->Key(),theKey))
return p->ChangeValue(); return p->ChangeValue();
p = (DataMapNode*) p->Next(); p = (DataMapNode*) p->Next();
} }
@ -341,3 +347,4 @@ template <class TheKeyType, class TheItemType> class NCollection_DataMap
#endif #endif
#endif #endif

56
src/NCollection/NCollection_DefaultHasher.hxx Normal file
View File

@ -0,0 +1,56 @@
// File: NCollection_DefaultHasher.hxx
// Created:
// Author: Eugene Maltchikov
//
#ifndef NCollection_DefaultHasher_HeaderFile
#define NCollection_DefaultHasher_HeaderFile
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//=======================================================================
//function : HashCode_Proxy
//purpose : Function is required to call the global function HashCode.
//=======================================================================
template <class TheKeyType>
static Standard_Integer HashCode_Proxy(const TheKeyType& theKey,
const Standard_Integer Upper) {
return HashCode(theKey, Upper);
}
//=======================================================================
//function : IsEqual_Proxy
//purpose : Function is required to call the global function IsEqual.
//=======================================================================
template <class TheKeyType>
static Standard_Boolean IsEqual_Proxy(const TheKeyType& theKey1,
const TheKeyType& theKey2) {
return IsEqual(theKey1, theKey2);
}
/**
* Purpose: The DefaultHasher is a Hasher that is used by
* default in NCollection maps.
* To compute the hash code of the key is used the
* global function HashCode.
* To compare two keys is used the global function
* IsEqual.
*/
template <class TheKeyType> class NCollection_DefaultHasher {
public:
//
static Standard_Integer HashCode(const TheKeyType& theKey,
const Standard_Integer Upper) {
return HashCode_Proxy(theKey, Upper);
}
//
static Standard_Boolean IsEqual(const TheKeyType& theKey1,
const TheKeyType& theKey2) {
return IsEqual_Proxy(theKey1, theKey2);
}
};
#endif

60
src/NCollection/NCollection_DoubleMap.hxx
View File

@ -15,6 +15,8 @@
#include <Standard_ImmutableObject.hxx> #include <Standard_ImmutableObject.hxx>
#include <Standard_NoSuchObject.hxx> #include <Standard_NoSuchObject.hxx>
#include <NCollection_DefaultHasher.hxx>
#ifdef WNT #ifdef WNT
// Disable the warning "operator new unmatched by delete" // Disable the warning "operator new unmatched by delete"
#pragma warning (push) #pragma warning (push)
@ -28,7 +30,11 @@
* See Map from NCollection for a discussion about the number * See Map from NCollection for a discussion about the number
* of buckets * of buckets
*/ */
template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
template < class TheKey1Type,
class TheKey2Type,
class Hasher1 = NCollection_DefaultHasher<TheKey1Type>,
class Hasher2 = NCollection_DefaultHasher<TheKey2Type> > class NCollection_DoubleMap
: public NCollection_BaseCollection<TheKey2Type>, : public NCollection_BaseCollection<TheKey2Type>,
public NCollection_BaseMap public NCollection_BaseMap
{ {
@ -164,8 +170,8 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
TheKey1Type aKey1 = anIter.Key1(); TheKey1Type aKey1 = anIter.Key1();
TheKey2Type aKey2 = anIter.Key2(); TheKey2Type aKey2 = anIter.Key2();
Standard_Integer iK1 = HashCode (aKey1, NbBuckets()); Standard_Integer iK1 = Hasher1::HashCode (aKey1, NbBuckets());
Standard_Integer iK2 = HashCode (aKey2, NbBuckets()); Standard_Integer iK2 = Hasher2::HashCode (aKey2, NbBuckets());
DoubleMapNode * pNode = new (this->myAllocator) DoubleMapNode (aKey1, aKey2, DoubleMapNode * pNode = new (this->myAllocator) DoubleMapNode (aKey1, aKey2,
myData1[iK1], myData1[iK1],
myData2[iK2]); myData2[iK2]);
@ -198,8 +204,8 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
p = (DoubleMapNode *) myData1[i]; p = (DoubleMapNode *) myData1[i];
while (p) while (p)
{ {
iK1 = HashCode (p->Key1(), newBuck); iK1 = Hasher1::HashCode (p->Key1(), newBuck);
iK2 = HashCode (p->Key2(), newBuck); iK2 = Hasher2::HashCode (p->Key2(), newBuck);
q = (DoubleMapNode*) p->Next(); q = (DoubleMapNode*) p->Next();
p->Next() = ppNewData1[iK1]; p->Next() = ppNewData1[iK1];
p->Next2() = ppNewData2[iK2]; p->Next2() = ppNewData2[iK2];
@ -222,20 +228,20 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
if (Resizable()) if (Resizable())
ReSize(Extent()); ReSize(Extent());
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher1::HashCode (theKey1, NbBuckets());
Standard_Integer iK2 = HashCode (theKey2, NbBuckets()); Standard_Integer iK2 = Hasher2::HashCode (theKey2, NbBuckets());
DoubleMapNode * pNode; DoubleMapNode * pNode;
pNode = (DoubleMapNode *) myData1[iK1]; pNode = (DoubleMapNode *) myData1[iK1];
while (pNode) while (pNode)
{ {
if (IsEqual (pNode->Key1(), theKey1)) if (Hasher1::IsEqual (pNode->Key1(), theKey1))
Standard_MultiplyDefined::Raise("NCollection_DoubleMap:Bind"); Standard_MultiplyDefined::Raise("NCollection_DoubleMap:Bind");
pNode = (DoubleMapNode *) pNode->Next(); pNode = (DoubleMapNode *) pNode->Next();
} }
pNode = (DoubleMapNode *) myData2[iK2]; pNode = (DoubleMapNode *) myData2[iK2];
while (pNode) while (pNode)
{ {
if (IsEqual (pNode->Key2(), theKey2)) if (Hasher2::IsEqual (pNode->Key2(), theKey2))
Standard_MultiplyDefined::Raise("NCollection_DoubleMap:Bind"); Standard_MultiplyDefined::Raise("NCollection_DoubleMap:Bind");
pNode = (DoubleMapNode *) pNode->Next(); pNode = (DoubleMapNode *) pNode->Next();
} }
@ -252,13 +258,13 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher1::HashCode (theKey1, NbBuckets());
Standard_Integer iK2 = HashCode (theKey2, NbBuckets()); Standard_Integer iK2 = Hasher2::HashCode (theKey2, NbBuckets());
DoubleMapNode * pNode1, * pNode2; DoubleMapNode * pNode1, * pNode2;
pNode1 = (DoubleMapNode *) myData1[iK1]; pNode1 = (DoubleMapNode *) myData1[iK1];
while (pNode1) while (pNode1)
{ {
if (IsEqual(pNode1->Key1(), theKey1)) if (Hasher1::IsEqual(pNode1->Key1(), theKey1))
break; break;
pNode1 = (DoubleMapNode *) pNode1->Next(); pNode1 = (DoubleMapNode *) pNode1->Next();
} }
@ -267,7 +273,7 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
pNode2 = (DoubleMapNode *) myData2[iK2]; pNode2 = (DoubleMapNode *) myData2[iK2];
while (pNode2) while (pNode2)
{ {
if (IsEqual(pNode2->Key2(), theKey2)) if (Hasher2::IsEqual(pNode2->Key2(), theKey2))
break; break;
pNode2 = (DoubleMapNode *) pNode2->Next(); pNode2 = (DoubleMapNode *) pNode2->Next();
} }
@ -282,12 +288,12 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher1::HashCode (theKey1, NbBuckets());
DoubleMapNode * pNode1; DoubleMapNode * pNode1;
pNode1 = (DoubleMapNode *) myData1[iK1]; pNode1 = (DoubleMapNode *) myData1[iK1];
while (pNode1) while (pNode1)
{ {
if (IsEqual(pNode1->Key1(), theKey1)) if (Hasher1::IsEqual(pNode1->Key1(), theKey1))
return Standard_True; return Standard_True;
pNode1 = (DoubleMapNode *) pNode1->Next(); pNode1 = (DoubleMapNode *) pNode1->Next();
} }
@ -299,12 +305,12 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK2 = HashCode (theKey2, NbBuckets()); Standard_Integer iK2 = Hasher2::HashCode (theKey2, NbBuckets());
DoubleMapNode * pNode2; DoubleMapNode * pNode2;
pNode2 = (DoubleMapNode *) myData2[iK2]; pNode2 = (DoubleMapNode *) myData2[iK2];
while (pNode2) while (pNode2)
{ {
if (IsEqual(pNode2->Key2(), theKey2)) if (Hasher2::IsEqual(pNode2->Key2(), theKey2))
return Standard_True; return Standard_True;
pNode2 = (DoubleMapNode *) pNode2->Next2(); pNode2 = (DoubleMapNode *) pNode2->Next2();
} }
@ -316,20 +322,20 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher1::HashCode (theKey1, NbBuckets());
DoubleMapNode * p1, * p2, * q1, *q2; DoubleMapNode * p1, * p2, * q1, *q2;
q1 = q2 = NULL; q1 = q2 = NULL;
p1 = (DoubleMapNode *) myData1[iK1]; p1 = (DoubleMapNode *) myData1[iK1];
while (p1) while (p1)
{ {
if (IsEqual (p1->Key1(), theKey1)) if (Hasher1::IsEqual (p1->Key1(), theKey1))
{ {
// remove from the data1 // remove from the data1
if (q1) if (q1)
q1->Next() = p1->Next(); q1->Next() = p1->Next();
else else
myData1[iK1] = (DoubleMapNode*) p1->Next(); myData1[iK1] = (DoubleMapNode*) p1->Next();
Standard_Integer iK2 = HashCode (p1->Key2(), NbBuckets()); Standard_Integer iK2 = Hasher2::HashCode (p1->Key2(), NbBuckets());
p2 = (DoubleMapNode *) myData2[iK2]; p2 = (DoubleMapNode *) myData2[iK2];
while (p2) while (p2)
{ {
@ -361,20 +367,20 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK2 = HashCode (theKey2, NbBuckets()); Standard_Integer iK2 = Hasher2::HashCode (theKey2, NbBuckets());
DoubleMapNode * p1, * p2, * q1, *q2; DoubleMapNode * p1, * p2, * q1, *q2;
q1 = q2 = NULL; q1 = q2 = NULL;
p2 = (DoubleMapNode *) myData2[iK2]; p2 = (DoubleMapNode *) myData2[iK2];
while (p2) while (p2)
{ {
if (IsEqual (p2->Key2(), theKey2)) if (Hasher2::IsEqual (p2->Key2(), theKey2))
{ {
// remove from the data2 // remove from the data2
if (q2) if (q2)
q2->Next() = p2->Next(); q2->Next() = p2->Next();
else else
myData2[iK2] = (DoubleMapNode*) p2->Next2(); myData2[iK2] = (DoubleMapNode*) p2->Next2();
Standard_Integer iK1 = HashCode (p2->Key1(), NbBuckets()); Standard_Integer iK1 = Hasher1::HashCode (p2->Key1(), NbBuckets());
p1 = (DoubleMapNode *) myData1[iK1]; p1 = (DoubleMapNode *) myData1[iK1];
while (p1) while (p1)
{ {
@ -409,10 +415,10 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
Standard_NoSuchObject::Raise ("NCollection_DoubleMap::Find1"); Standard_NoSuchObject::Raise ("NCollection_DoubleMap::Find1");
#endif #endif
DoubleMapNode * pNode1 = DoubleMapNode * pNode1 =
(DoubleMapNode *) myData1[HashCode(theKey1,NbBuckets())]; (DoubleMapNode *) myData1[Hasher1::HashCode(theKey1,NbBuckets())];
while (pNode1) while (pNode1)
{ {
if (IsEqual (pNode1->Key1(), theKey1)) if (Hasher1::IsEqual (pNode1->Key1(), theKey1))
return pNode1->Key2(); return pNode1->Key2();
pNode1 = (DoubleMapNode*) pNode1->Next(); pNode1 = (DoubleMapNode*) pNode1->Next();
} }
@ -428,10 +434,10 @@ template <class TheKey1Type, class TheKey2Type> class NCollection_DoubleMap
Standard_NoSuchObject::Raise ("NCollection_DoubleMap::Find2"); Standard_NoSuchObject::Raise ("NCollection_DoubleMap::Find2");
#endif #endif
DoubleMapNode * pNode2 = DoubleMapNode * pNode2 =
(DoubleMapNode *) myData2[HashCode(theKey2,NbBuckets())]; (DoubleMapNode *) myData2[Hasher2::HashCode(theKey2,NbBuckets())];
while (pNode2) while (pNode2)
{ {
if (IsEqual (pNode2->Key2(), theKey2)) if (Hasher2::IsEqual (pNode2->Key2(), theKey2))
return pNode2->Key1(); return pNode2->Key1();
pNode2 = (DoubleMapNode*) pNode2->Next2(); pNode2 = (DoubleMapNode*) pNode2->Next2();
} }

57
src/NCollection/NCollection_IndexedDataMap.hxx
View File

@ -11,6 +11,9 @@
#include <NCollection_TListNode.hxx> #include <NCollection_TListNode.hxx>
#include <Standard_TypeMismatch.hxx> #include <Standard_TypeMismatch.hxx>
#include <Standard_NoSuchObject.hxx> #include <Standard_NoSuchObject.hxx>
#include <NCollection_DefaultHasher.hxx>
#if !defined No_Exception && !defined No_Standard_OutOfRange #if !defined No_Exception && !defined No_Standard_OutOfRange
#include <Standard_OutOfRange.hxx> #include <Standard_OutOfRange.hxx>
#endif #endif
@ -39,7 +42,11 @@
* See the class Map from NCollection for a * See the class Map from NCollection for a
* discussion about the number of buckets. * discussion about the number of buckets.
*/ */
template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
template < class TheKeyType,
class TheItemType,
class Hasher = NCollection_DefaultHasher<TheKeyType> >
class NCollection_IndexedDataMap
: public NCollection_BaseCollection<TheItemType>, : public NCollection_BaseCollection<TheItemType>,
public NCollection_BaseMap public NCollection_BaseMap
{ {
@ -167,8 +174,8 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
{ {
TheKeyType aKey1 = theOther.FindKey(i); TheKeyType aKey1 = theOther.FindKey(i);
TheItemType anItem = theOther.FindFromIndex(i); TheItemType anItem = theOther.FindFromIndex(i);
Standard_Integer iK1 = HashCode (aKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (aKey1, NbBuckets());
Standard_Integer iK2 = HashCode (i, NbBuckets()); Standard_Integer iK2 = ::HashCode (i, NbBuckets());
IndexedDataMapNode * pNode = IndexedDataMapNode * pNode =
new (this->myAllocator) IndexedDataMapNode (aKey1, i, anItem, new (this->myAllocator) IndexedDataMapNode (aKey1, i, anItem,
myData1[iK1], myData2[iK2]); myData1[iK1], myData2[iK2]);
@ -201,8 +208,8 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
p = (IndexedDataMapNode *) myData1[i]; p = (IndexedDataMapNode *) myData1[i];
while (p) while (p)
{ {
iK1 = HashCode (p->Key1(), newBuck); iK1 = Hasher::HashCode (p->Key1(), newBuck);
iK2 = HashCode (p->Key2(), newBuck); iK2 = ::HashCode (p->Key2(), newBuck);
q = (IndexedDataMapNode*) p->Next(); q = (IndexedDataMapNode*) p->Next();
p->Next() = ppNewData1[iK1]; p->Next() = ppNewData1[iK1];
p->Next2() = ppNewData2[iK2]; p->Next2() = ppNewData2[iK2];
@ -225,17 +232,17 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
{ {
if (Resizable()) if (Resizable())
ReSize(Extent()); ReSize(Extent());
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (theKey1, NbBuckets());
IndexedDataMapNode * pNode; IndexedDataMapNode * pNode;
pNode = (IndexedDataMapNode *) myData1[iK1]; pNode = (IndexedDataMapNode *) myData1[iK1];
while (pNode) while (pNode)
{ {
if (IsEqual (pNode->Key1(), theKey1)) if (Hasher::IsEqual (pNode->Key1(), theKey1))
return pNode->Key2(); return pNode->Key2();
pNode = (IndexedDataMapNode *) pNode->Next(); pNode = (IndexedDataMapNode *) pNode->Next();
} }
Increment(); Increment();
Standard_Integer iK2 = HashCode(Extent(),NbBuckets()); Standard_Integer iK2 = ::HashCode(Extent(),NbBuckets());
pNode = new (this->myAllocator) IndexedDataMapNode (theKey1, Extent(), theItem, pNode = new (this->myAllocator) IndexedDataMapNode (theKey1, Extent(), theItem,
myData1[iK1], myData2[iK2]); myData1[iK1], myData2[iK2]);
myData1[iK1] = pNode; myData1[iK1] = pNode;
@ -248,12 +255,12 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (theKey1, NbBuckets());
IndexedDataMapNode * pNode1; IndexedDataMapNode * pNode1;
pNode1 = (IndexedDataMapNode *) myData1[iK1]; pNode1 = (IndexedDataMapNode *) myData1[iK1];
while (pNode1) while (pNode1)
{ {
if (IsEqual(pNode1->Key1(), theKey1)) if (Hasher::IsEqual(pNode1->Key1(), theKey1))
return Standard_True; return Standard_True;
pNode1 = (IndexedDataMapNode *) pNode1->Next(); pNode1 = (IndexedDataMapNode *) pNode1->Next();
} }
@ -271,17 +278,17 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
#endif #endif
IndexedDataMapNode * p; IndexedDataMapNode * p;
// check if theKey1 is not already in the map // check if theKey1 is not already in the map
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (theKey1, NbBuckets());
p = (IndexedDataMapNode *) myData1[iK1]; p = (IndexedDataMapNode *) myData1[iK1];
while (p) while (p)
{ {
if (IsEqual (p->Key1(), theKey1)) if (Hasher::IsEqual (p->Key1(), theKey1))
Standard_DomainError::Raise("NCollection_IndexedDataMap::Substitute"); Standard_DomainError::Raise("NCollection_IndexedDataMap::Substitute");
p = (IndexedDataMapNode *) p->Next(); p = (IndexedDataMapNode *) p->Next();
} }
// Find the node for the index I // Find the node for the index I
Standard_Integer iK2 = HashCode (theIndex, NbBuckets()); Standard_Integer iK2 = ::HashCode (theIndex, NbBuckets());
p = (IndexedDataMapNode *) myData2[iK2]; p = (IndexedDataMapNode *) myData2[iK2];
while (p) while (p)
{ {
@ -291,7 +298,7 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
} }
// remove the old key // remove the old key
Standard_Integer iK = HashCode (p->Key1(), NbBuckets()); Standard_Integer iK = Hasher::HashCode (p->Key1(), NbBuckets());
IndexedDataMapNode * q = (IndexedDataMapNode *) myData1[iK]; IndexedDataMapNode * q = (IndexedDataMapNode *) myData1[iK];
if (q == p) if (q == p)
myData1[iK] = (IndexedDataMapNode *) p->Next(); myData1[iK] = (IndexedDataMapNode *) p->Next();
@ -318,7 +325,7 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
#endif #endif
IndexedDataMapNode * p, * q; IndexedDataMapNode * p, * q;
// Find the node for the last index and remove it // Find the node for the last index and remove it
Standard_Integer iK2 = HashCode (Extent(), NbBuckets()); Standard_Integer iK2 = ::HashCode (Extent(), NbBuckets());
p = (IndexedDataMapNode *) myData2[iK2]; p = (IndexedDataMapNode *) myData2[iK2];
q = NULL; q = NULL;
while (p) while (p)
@ -334,7 +341,7 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
q->Next2() = p->Next2(); q->Next2() = p->Next2();
// remove the key // remove the key
Standard_Integer iK1 = HashCode (p->Key1(), NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (p->Key1(), NbBuckets());
q = (IndexedDataMapNode *) myData1[iK1]; q = (IndexedDataMapNode *) myData1[iK1];
if (q == p) if (q == p)
myData1[iK1] = (IndexedDataMapNode *) p->Next(); myData1[iK1] = (IndexedDataMapNode *) p->Next();
@ -357,7 +364,7 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
Standard_OutOfRange::Raise ("NCollection_IndexedDataMap::FindKey"); Standard_OutOfRange::Raise ("NCollection_IndexedDataMap::FindKey");
#endif #endif
IndexedDataMapNode * pNode2 = IndexedDataMapNode * pNode2 =
(IndexedDataMapNode *) myData2[HashCode(theKey2,NbBuckets())]; (IndexedDataMapNode *) myData2[::HashCode(theKey2,NbBuckets())];
while (pNode2) while (pNode2)
{ {
if (pNode2->Key2() == theKey2) if (pNode2->Key2() == theKey2)
@ -376,7 +383,7 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
Standard_OutOfRange::Raise ("NCollection_IndexedDataMap::FindFromIndex"); Standard_OutOfRange::Raise ("NCollection_IndexedDataMap::FindFromIndex");
#endif #endif
IndexedDataMapNode * pNode2 = IndexedDataMapNode * pNode2 =
(IndexedDataMapNode *) myData2[HashCode(theKey2,NbBuckets())]; (IndexedDataMapNode *) myData2[::HashCode(theKey2,NbBuckets())];
while (pNode2) while (pNode2)
{ {
if (pNode2->Key2() == theKey2) if (pNode2->Key2() == theKey2)
@ -399,7 +406,7 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
Standard_OutOfRange::Raise("NCollection_IndexedDataMap::ChangeFromIndex"); Standard_OutOfRange::Raise("NCollection_IndexedDataMap::ChangeFromIndex");
#endif #endif
IndexedDataMapNode * pNode2 = IndexedDataMapNode * pNode2 =
(IndexedDataMapNode *) myData2[HashCode(theKey2,NbBuckets())]; (IndexedDataMapNode *) myData2[::HashCode(theKey2,NbBuckets())];
while (pNode2) while (pNode2)
{ {
if (pNode2->Key2() == theKey2) if (pNode2->Key2() == theKey2)
@ -419,10 +426,10 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
{ {
if (IsEmpty()) return 0; if (IsEmpty()) return 0;
IndexedDataMapNode * pNode1 = IndexedDataMapNode * pNode1 =
(IndexedDataMapNode *) myData1[HashCode(theKey1,NbBuckets())]; (IndexedDataMapNode *) myData1[Hasher::HashCode(theKey1,NbBuckets())];
while (pNode1) while (pNode1)
{ {
if (IsEqual (pNode1->Key1(), theKey1)) if (Hasher::IsEqual (pNode1->Key1(), theKey1))
return pNode1->Key2(); return pNode1->Key2();
pNode1 = (IndexedDataMapNode*) pNode1->Next(); pNode1 = (IndexedDataMapNode*) pNode1->Next();
} }
@ -437,10 +444,10 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
Standard_NoSuchObject::Raise ("NCollection_IndexedDataMap::FindFromKey"); Standard_NoSuchObject::Raise ("NCollection_IndexedDataMap::FindFromKey");
#endif #endif
IndexedDataMapNode * pNode1 = IndexedDataMapNode * pNode1 =
(IndexedDataMapNode *) myData1[HashCode(theKey1,NbBuckets())]; (IndexedDataMapNode *) myData1[Hasher::HashCode(theKey1,NbBuckets())];
while (pNode1) while (pNode1)
{ {
if (IsEqual (pNode1->Key1(), theKey1)) if (Hasher::IsEqual (pNode1->Key1(), theKey1))
return pNode1->Value(); return pNode1->Value();
pNode1 = (IndexedDataMapNode*) pNode1->Next(); pNode1 = (IndexedDataMapNode*) pNode1->Next();
} }
@ -456,10 +463,10 @@ template <class TheKeyType, class TheItemType> class NCollection_IndexedDataMap
Standard_NoSuchObject::Raise("NCollection_IndexedDataMap::ChangeFromKey"); Standard_NoSuchObject::Raise("NCollection_IndexedDataMap::ChangeFromKey");
#endif #endif
IndexedDataMapNode * pNode1 = IndexedDataMapNode * pNode1 =
(IndexedDataMapNode *) myData1[HashCode(theKey1,NbBuckets())]; (IndexedDataMapNode *) myData1[Hasher::HashCode(theKey1,NbBuckets())];
while (pNode1) while (pNode1)
{ {
if (IsEqual (pNode1->Key1(), theKey1)) if (Hasher::IsEqual (pNode1->Key1(), theKey1))
return pNode1->ChangeValue(); return pNode1->ChangeValue();
pNode1 = (IndexedDataMapNode*) pNode1->Next(); pNode1 = (IndexedDataMapNode*) pNode1->Next();
} }

43
src/NCollection/NCollection_IndexedMap.hxx
View File

@ -12,6 +12,8 @@
#include <Standard_NoSuchObject.hxx> #include <Standard_NoSuchObject.hxx>
#include <Standard_ImmutableObject.hxx> #include <Standard_ImmutableObject.hxx>
#include <NCollection_DefaultHasher.hxx>
#if !defined No_Exception && !defined No_Standard_OutOfRange #if !defined No_Exception && !defined No_Standard_OutOfRange
#include <Standard_OutOfRange.hxx> #include <Standard_OutOfRange.hxx>
#endif #endif
@ -32,7 +34,10 @@
* See the class Map from NCollection for a * See the class Map from NCollection for a
* discussion about the number of buckets. * discussion about the number of buckets.
*/ */
template <class TheKeyType> class NCollection_IndexedMap
template < class TheKeyType,
class Hasher = NCollection_DefaultHasher<TheKeyType> >
class NCollection_IndexedMap
: public NCollection_BaseCollection<TheKeyType>, : public NCollection_BaseCollection<TheKeyType>,
public NCollection_BaseMap public NCollection_BaseMap
{ {
@ -160,8 +165,8 @@ template <class TheKeyType> class NCollection_IndexedMap
for (i=1; i<=iLength; i++) for (i=1; i<=iLength; i++)
{ {
TheKeyType aKey1 = theOther(i); TheKeyType aKey1 = theOther(i);
Standard_Integer iK1 = HashCode (aKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (aKey1, NbBuckets());
Standard_Integer iK2 = HashCode (i, NbBuckets()); Standard_Integer iK2 = ::HashCode (i, NbBuckets());
IndexedMapNode * pNode = new (this->myAllocator) IndexedMapNode (aKey1, i, IndexedMapNode * pNode = new (this->myAllocator) IndexedMapNode (aKey1, i,
myData1[iK1], myData1[iK1],
myData2[iK2]); myData2[iK2]);
@ -194,13 +199,13 @@ template <class TheKeyType> class NCollection_IndexedMap
p = (IndexedMapNode *) myData1[i]; p = (IndexedMapNode *) myData1[i];
while (p) while (p)
{ {
iK1 = HashCode (p->Key1(), newBuck); iK1 =Hasher::HashCode(p->Key1(), newBuck);
q = (IndexedMapNode*) p->Next(); q = (IndexedMapNode*) p->Next();
p->Next() = ppNewData1[iK1]; p->Next() = ppNewData1[iK1];
ppNewData1[iK1] = p; ppNewData1[iK1] = p;
if (p->Key2() > 0) if (p->Key2() > 0)
{ {
iK2 = HashCode (p->Key2(), newBuck); iK2 = ::HashCode (p->Key2(), newBuck);
p->Next2() = ppNewData2[iK2]; p->Next2() = ppNewData2[iK2];
ppNewData2[iK2] = p; ppNewData2[iK2] = p;
} }
@ -221,17 +226,17 @@ template <class TheKeyType> class NCollection_IndexedMap
{ {
if (Resizable()) if (Resizable())
ReSize(Extent()); ReSize(Extent());
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (theKey1, NbBuckets());
IndexedMapNode * pNode; IndexedMapNode * pNode;
pNode = (IndexedMapNode *) myData1[iK1]; pNode = (IndexedMapNode *) myData1[iK1];
while (pNode) while (pNode)
{ {
if (IsEqual (pNode->Key1(), theKey1)) if (Hasher::IsEqual (pNode->Key1(), theKey1))
return pNode->Key2(); return pNode->Key2();
pNode = (IndexedMapNode *) pNode->Next(); pNode = (IndexedMapNode *) pNode->Next();
} }
Increment(); Increment();
Standard_Integer iK2 = HashCode(Extent(),NbBuckets()); Standard_Integer iK2 = ::HashCode(Extent(),NbBuckets());
pNode = new (this->myAllocator) IndexedMapNode (theKey1, Extent(), pNode = new (this->myAllocator) IndexedMapNode (theKey1, Extent(),
myData1[iK1], myData2[iK2]); myData1[iK1], myData2[iK2]);
myData1[iK1] = pNode; myData1[iK1] = pNode;
@ -244,12 +249,12 @@ template <class TheKeyType> class NCollection_IndexedMap
{ {
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (theKey1, NbBuckets());
IndexedMapNode * pNode1; IndexedMapNode * pNode1;
pNode1 = (IndexedMapNode *) myData1[iK1]; pNode1 = (IndexedMapNode *) myData1[iK1];
while (pNode1) while (pNode1)
{ {
if (IsEqual(pNode1->Key1(), theKey1)) if (Hasher::IsEqual(pNode1->Key1(), theKey1))
return Standard_True; return Standard_True;
pNode1 = (IndexedMapNode *) pNode1->Next(); pNode1 = (IndexedMapNode *) pNode1->Next();
} }
@ -266,17 +271,17 @@ template <class TheKeyType> class NCollection_IndexedMap
#endif #endif
IndexedMapNode * p; IndexedMapNode * p;
// check if theKey1 is not already in the map // check if theKey1 is not already in the map
Standard_Integer iK1 = HashCode (theKey1, NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (theKey1, NbBuckets());
p = (IndexedMapNode *) myData1[iK1]; p = (IndexedMapNode *) myData1[iK1];
while (p) while (p)
{ {
if (IsEqual (p->Key1(), theKey1)) if (Hasher::IsEqual (p->Key1(), theKey1))
Standard_DomainError::Raise("NCollection_IndexedMap::Substitute"); Standard_DomainError::Raise("NCollection_IndexedMap::Substitute");
p = (IndexedMapNode *) p->Next(); p = (IndexedMapNode *) p->Next();
} }
// Find the node for the index I // Find the node for the index I
Standard_Integer iK2 = HashCode (theIndex, NbBuckets()); Standard_Integer iK2 = ::HashCode (theIndex, NbBuckets());
p = (IndexedMapNode *) myData2[iK2]; p = (IndexedMapNode *) myData2[iK2];
while (p) while (p)
{ {
@ -286,7 +291,7 @@ template <class TheKeyType> class NCollection_IndexedMap
} }
// remove the old key // remove the old key
Standard_Integer iK = HashCode (p->Key1(), NbBuckets()); Standard_Integer iK = Hasher::HashCode (p->Key1(), NbBuckets());
IndexedMapNode * q = (IndexedMapNode *) myData1[iK]; IndexedMapNode * q = (IndexedMapNode *) myData1[iK];
if (q == p) if (q == p)
myData1[iK] = (IndexedMapNode *) p->Next(); myData1[iK] = (IndexedMapNode *) p->Next();
@ -312,7 +317,7 @@ template <class TheKeyType> class NCollection_IndexedMap
#endif #endif
IndexedMapNode * p, * q; IndexedMapNode * p, * q;
// Find the node for the last index and remove it // Find the node for the last index and remove it
Standard_Integer iK2 = HashCode (Extent(), NbBuckets()); Standard_Integer iK2 = ::HashCode (Extent(), NbBuckets());
p = (IndexedMapNode *) myData2[iK2]; p = (IndexedMapNode *) myData2[iK2];
q = NULL; q = NULL;
while (p) while (p)
@ -328,7 +333,7 @@ template <class TheKeyType> class NCollection_IndexedMap
q->Next2() = p->Next2(); q->Next2() = p->Next2();
// remove the key // remove the key
Standard_Integer iK1 = HashCode (p->Key1(), NbBuckets()); Standard_Integer iK1 = Hasher::HashCode (p->Key1(), NbBuckets());
q = (IndexedMapNode *) myData1[iK1]; q = (IndexedMapNode *) myData1[iK1];
if (q == p) if (q == p)
myData1[iK1] = (IndexedMapNode *) p->Next(); myData1[iK1] = (IndexedMapNode *) p->Next();
@ -351,7 +356,7 @@ template <class TheKeyType> class NCollection_IndexedMap
Standard_OutOfRange::Raise ("NCollection_IndexedMap::FindKey"); Standard_OutOfRange::Raise ("NCollection_IndexedMap::FindKey");
#endif #endif
IndexedMapNode * pNode2 = IndexedMapNode * pNode2 =
(IndexedMapNode *) myData2[HashCode(theKey2,NbBuckets())]; (IndexedMapNode *) myData2[::HashCode(theKey2,NbBuckets())];
while (pNode2) while (pNode2)
{ {
if (pNode2->Key2() == theKey2) if (pNode2->Key2() == theKey2)
@ -371,10 +376,10 @@ template <class TheKeyType> class NCollection_IndexedMap
{ {
if (IsEmpty()) return 0; if (IsEmpty()) return 0;
IndexedMapNode * pNode1 = IndexedMapNode * pNode1 =
(IndexedMapNode *) myData1[HashCode(theKey1,NbBuckets())]; (IndexedMapNode *) myData1[Hasher::HashCode(theKey1,NbBuckets())];
while (pNode1) while (pNode1)
{ {
if (IsEqual (pNode1->Key1(), theKey1)) if (Hasher::IsEqual (pNode1->Key1(), theKey1))
return pNode1->Key2(); return pNode1->Key2();
pNode1 = (IndexedMapNode*) pNode1->Next(); pNode1 = (IndexedMapNode*) pNode1->Next();
} }

26
src/NCollection/NCollection_Map.hxx
View File

@ -9,6 +9,9 @@
#include <NCollection_BaseCollection.hxx> #include <NCollection_BaseCollection.hxx>
#include <NCollection_BaseMap.hxx> #include <NCollection_BaseMap.hxx>
#include <NCollection_TListNode.hxx> #include <NCollection_TListNode.hxx>
#include <NCollection_DefaultHasher.hxx>
#include <Standard_ImmutableObject.hxx> #include <Standard_ImmutableObject.hxx>
#if !defined No_Exception && !defined No_Standard_NoSuchObject #if !defined No_Exception && !defined No_Standard_NoSuchObject
@ -48,12 +51,15 @@
* method. This should be consider only for crucial * method. This should be consider only for crucial
* optimisation issues. * optimisation issues.
*/ */
template <class TheKeyType> class NCollection_Map
template < class TheKeyType,
class Hasher = NCollection_DefaultHasher<TheKeyType> > class NCollection_Map
: public NCollection_BaseCollection<TheKeyType>, : public NCollection_BaseCollection<TheKeyType>,
public NCollection_BaseMap public NCollection_BaseMap
{ {
//! Adaptation of the TListNode to the map notations //! Adaptation of the TListNode to the map notations
public: public:
class MapNode : public NCollection_TListNode<TheKeyType> class MapNode : public NCollection_TListNode<TheKeyType>
{ {
public: public:
@ -182,7 +188,7 @@ template <class TheKeyType> class NCollection_Map
p = olddata[i]; p = olddata[i];
while (p) while (p)
{ {
k = HashCode(p->Key(),newBuck); k = Hasher::HashCode(p->Key(),newBuck);
q = (MapNode*) p->Next(); q = (MapNode*) p->Next();
p->Next() = newdata[k]; p->Next() = newdata[k];
newdata[k] = p; newdata[k] = p;
@ -204,11 +210,11 @@ template <class TheKeyType> class NCollection_Map
if (Resizable()) if (Resizable())
ReSize(Extent()); ReSize(Extent());
MapNode** data = (MapNode**)myData1; MapNode** data = (MapNode**)myData1;
Standard_Integer k = HashCode(K,NbBuckets()); Standard_Integer k = Hasher::HashCode(K,NbBuckets());
MapNode* p = data[k]; MapNode* p = data[k];
while (p) while (p)
{ {
if (IsEqual(p->Key(),K)) if (Hasher::IsEqual(p->Key(),K))
return Standard_False; return Standard_False;
p = (MapNode *) p->Next(); p = (MapNode *) p->Next();
} }
@ -224,11 +230,11 @@ template <class TheKeyType> class NCollection_Map
if (Resizable()) if (Resizable())
ReSize(Extent()); ReSize(Extent());
MapNode** data = (MapNode**)myData1; MapNode** data = (MapNode**)myData1;
Standard_Integer k = HashCode(K,NbBuckets()); Standard_Integer k = Hasher::HashCode(K,NbBuckets());
MapNode* p = data[k]; MapNode* p = data[k];
while (p) while (p)
{ {
if (IsEqual(p->Key(),K)) if (Hasher::IsEqual(p->Key(),K))
return p->Key(); return p->Key();
p = (MapNode *) p->Next(); p = (MapNode *) p->Next();
} }
@ -243,10 +249,10 @@ template <class TheKeyType> class NCollection_Map
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
MapNode** data = (MapNode**) myData1; MapNode** data = (MapNode**) myData1;
MapNode* p = data[HashCode(K,NbBuckets())]; MapNode* p = data[Hasher::HashCode(K,NbBuckets())];
while (p) while (p)
{ {
if (IsEqual(p->Key(),K)) if (Hasher::IsEqual(p->Key(),K))
return Standard_True; return Standard_True;
p = (MapNode *) p->Next(); p = (MapNode *) p->Next();
} }
@ -259,12 +265,12 @@ template <class TheKeyType> class NCollection_Map
if (IsEmpty()) if (IsEmpty())
return Standard_False; return Standard_False;
MapNode** data = (MapNode**) myData1; MapNode** data = (MapNode**) myData1;
Standard_Integer k = HashCode(K,NbBuckets()); Standard_Integer k = Hasher::HashCode(K,NbBuckets());
MapNode* p = data[k]; MapNode* p = data[k];
MapNode* q = NULL; MapNode* q = NULL;
while (p) while (p)
{ {
if (IsEqual(p->Key(),K)) if (Hasher::IsEqual(p->Key(),K))
{ {
Decrement(); Decrement();
if (q) if (q)