occt/src/TCollection/TCollection_DataMap.gxx

// Created on: 1993-01-08
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>

//=======================================================================
//function : TCollection_DataMap
//purpose  : 
//=======================================================================

TCollection_DataMap::TCollection_DataMap(const Standard_Integer NbBuckets) :
       TCollection_BasicMap(NbBuckets,Standard_True)
{
}

//=======================================================================
//function : TCollection_DataMap
//purpose  : 
//=======================================================================

TCollection_DataMap::TCollection_DataMap(const TCollection_DataMap& Other) :
       TCollection_BasicMap(Other.NbBuckets(),Standard_True)
{
  if (!Other.IsEmpty())
    Standard_DomainError::Raise("TCollection:Copy of DataMap");
}

//=======================================================================
//function : Assign
//purpose  : 
//=======================================================================

TCollection_DataMap& TCollection_DataMap::Assign
  (const TCollection_DataMap& Other)
{
  // very simple implementation
  // not optimal (recompute the hashcode values)

  if (this == &Other) return *this;
  Clear();
//  ReSize(Other.NbBuckets());
  if  (!Other.IsEmpty()) { 
    ReSize(Other.Extent());
    for (TCollection_DataMapIterator It(Other); It.More(); It.Next()) {
      Bind(It.Key(),It.Value());
    }
  }
  return *this;
}


//=======================================================================
//function : ReSize
//purpose  : 
//=======================================================================

void TCollection_DataMap::ReSize(const Standard_Integer N)
{
  Standard_Integer newBuck;
  Standard_Address newData1=NULL, dummy=NULL;
  if (BeginResize(N,newBuck,newData1,dummy)) {
    if (myData1) {
      TCollection_DataMapNode** newdata = (TCollection_DataMapNode**) newData1;
      TCollection_DataMapNode** olddata = (TCollection_DataMapNode**) myData1;
      TCollection_DataMapNode *p, *q;
      Standard_Integer i,k;
      for (i = 0; i <= NbBuckets(); i++) {
	if (olddata[i]) {
	  p = olddata[i];
	  while (p) {
	    k = Hasher::HashCode(p->Key(),newBuck);
	    q = (TCollection_DataMapNode*)  p->Next();
	    p->Next() = newdata[k];
	    newdata[k] = p;
	    p = q;
	  }
	}
      }
    }
    EndResize(N,newBuck,newData1,dummy);
  }
}

//=======================================================================
//function : Clear
//purpose  : 
//=======================================================================

void TCollection_DataMap::Clear()
{
  if (!IsEmpty()) {
    Standard_Integer i;
    TCollection_DataMapNode** data = (TCollection_DataMapNode**) myData1;
    TCollection_DataMapNode *p,*q;
    for (i = 0; i <= NbBuckets(); i++) {
      if (data[i]) {
	p = data[i];
	while (p) {
	  q = (TCollection_DataMapNode*) p->Next();
	  delete p;
	  p = q;
	}
      }
    }
  }
 TCollection_BasicMap::Destroy();
}

//=======================================================================
//function : Add
//purpose  : 
//=======================================================================

Standard_Boolean TCollection_DataMap::Bind(const TheKey& K, const TheItem& I)
{
  if (Resizable()) ReSize(Extent());
  TCollection_DataMapNode** data = (TCollection_DataMapNode**)myData1;
  Standard_Integer k = Hasher::HashCode(K,NbBuckets());
  TCollection_DataMapNode* p = data[k];
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      p->Value() = I;
      return Standard_False;
    }
    p = (TCollection_DataMapNode*) p->Next();
  }
  Increment();
  data[k] = new TCollection_DataMapNode(K,I,data[k]);
  return Standard_True;
}


//=======================================================================
//function : Remove
//purpose  : 
//=======================================================================

Standard_Boolean TCollection_DataMap::UnBind(const TheKey& K)
{
  if (IsEmpty()) return Standard_False;
  TCollection_DataMapNode** data = (TCollection_DataMapNode**) myData1;
  Standard_Integer k = Hasher::HashCode(K,NbBuckets());
  TCollection_DataMapNode* p = data[k];
  TCollection_DataMapNode* q = NULL;
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      Decrement();
      if (q) q->Next() = p->Next();
      else   data[k] = (TCollection_DataMapNode*) p->Next();
      delete p;
      return Standard_True;
    }
    q = p;
    p = (TCollection_DataMapNode*) p->Next();
  }
  return Standard_False;
}
//=======================================================================
//function : IsBound
//purpose  : 
//=======================================================================
Standard_Boolean TCollection_DataMap::IsBound(const TheKey& K) const
{
  if (IsEmpty()) return Standard_False;
  TCollection_DataMapNode** data = (TCollection_DataMapNode**) myData1;
  TCollection_DataMapNode* p = data[Hasher::HashCode(K,NbBuckets())];
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      return Standard_True;
      }
    p = (TCollection_DataMapNode*) p->Next();
  }
  return Standard_False;
}
//=======================================================================
//function : Find
//purpose  : 
//=======================================================================
const TheItem& TCollection_DataMap::Find(const TheKey& K) const
{
  Standard_NoSuchObject_Raise_if(IsEmpty(),"TCollection_DataMap::Find");
  TCollection_DataMapNode** data = (TCollection_DataMapNode**) myData1;
  TCollection_DataMapNode* p = data[Hasher::HashCode(K,NbBuckets())];
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      return p->Value();
      }
    p = (TCollection_DataMapNode*) p->Next();
  }
  Standard_NoSuchObject::Raise("TCollection_DataMap::Find");
  return p->Value();
}
//=======================================================================
//function : ChangeFind
//purpose  : 
//=======================================================================
TheItem& TCollection_DataMap::ChangeFind(const TheKey& K)
{
  Standard_NoSuchObject_Raise_if(IsEmpty(),"TCollection_DataMap::ChangeFind");
  TCollection_DataMapNode** data = (TCollection_DataMapNode**) myData1;
  TCollection_DataMapNode* p = data[Hasher::HashCode(K,NbBuckets())];
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      return p->Value();
      }
    p = (TCollection_DataMapNode*)  p->Next();
  }
  Standard_NoSuchObject::Raise("TCollection_DataMap::ChangeFind");
  return p->Value();
}
//modified by NIZNHY-PKV Tue Jul 05 09:54:14 2011f
//=======================================================================
//function : Find1
//purpose  : 
//=======================================================================
Standard_Address TCollection_DataMap::Find1(const TheKey& K) const
{
  TCollection_DataMap *pMap=(TCollection_DataMap *)this;
  return pMap->ChangeFind1(K);
}
//=======================================================================
//function : ChangeFind1
//purpose  : 
//=======================================================================
Standard_Address TCollection_DataMap::ChangeFind1(const TheKey& K)
{
  if (IsEmpty()) {
    return NULL;
  }
  TCollection_DataMapNode** data = (TCollection_DataMapNode**) myData1;
  TCollection_DataMapNode* p = data[Hasher::HashCode(K,NbBuckets())];
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      return (Standard_Address)&p->Value();
      }
    p = (TCollection_DataMapNode*)  p->Next();
  }
  return NULL;
}
//modified by NIZNHY-PKV Tue Jul 05 09:54:18 2011t




// method of the iterator

//=======================================================================
//function : Key
//purpose  : 
//=======================================================================

const TheKey& TCollection_DataMapIterator::Key() const
{
  Standard_NoSuchObject_Raise_if(!More(),"TCollection_DataMapIterator::Key");  
  return ((TCollection_DataMapNode*) myNode)->Key();
}


//=======================================================================
//function : Value
//purpose  : 
//=======================================================================

const TheItem& TCollection_DataMapIterator::Value() const
{
  Standard_NoSuchObject_Raise_if(!More(),"TCollection_DataMapIterator::Value");  
  return ((TCollection_DataMapNode*) myNode)->Value();
}