occt/src/TCollection/TCollection_Map.gxx

// Created on: 1993-01-07
// 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_Map
//purpose  : 
//=======================================================================

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

//=======================================================================
//function : TCollection_Map
//purpose  : 
//=======================================================================

TCollection_Map::TCollection_Map(const TCollection_Map& Other) :
       TCollection_BasicMap(Other.NbBuckets(),Standard_True)
{
  if  (!Other.IsEmpty()) { 
    ReSize(Other.Extent()); 
    for (TCollection_MapIterator It(Other); It.More(); It.Next()) {
      Add(It.Key());
    }
  }
}

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

TCollection_Map& TCollection_Map::Assign(const TCollection_Map& Other)
{
  if (this == &Other) return *this;
  Clear();
//  ReSize(Other.NbBuckets());
  if  (!Other.IsEmpty()) { 
    ReSize(Other.Extent()); 
    for (TCollection_MapIterator It(Other); It.More(); It.Next()) {
      Add(It.Key());
    }
  }
  return *this;
}


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

void TCollection_Map::ReSize(const Standard_Integer N)
{
  Standard_Integer newBuck;
  Standard_Address newData1=NULL, dummy=NULL;
  if (BeginResize(N,newBuck,newData1,dummy)) {
    if (myData1) {
      TCollection_StdMapNode** newdata = (TCollection_StdMapNode**)newData1;
      TCollection_StdMapNode** olddata = (TCollection_StdMapNode**) myData1;
      TCollection_StdMapNode *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_StdMapNode*) p->Next();
	    p->Next() = newdata[k];
	    newdata[k] = p;
	    p = q;
	  }
	}
      }
    }
    EndResize(N,newBuck,newData1,dummy);
  }
}

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

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

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

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

//=======================================================================
//function : Contains
//purpose  : 
//=======================================================================

Standard_Boolean TCollection_Map::Contains(const TheKey& K) const
{
  if (IsEmpty()) return Standard_False;
  TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1;
  TCollection_StdMapNode* p = data[Hasher::HashCode(K,NbBuckets())];
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      return Standard_True;
      }
    p = (TCollection_StdMapNode*)p->Next();
  }
  return Standard_False;
}

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

Standard_Boolean TCollection_Map::Remove(const TheKey& K)
{
  if (IsEmpty()) return Standard_False;
  TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1;
  Standard_Integer k = Hasher::HashCode(K,NbBuckets());
  TCollection_StdMapNode* p = data[k];
  TCollection_StdMapNode* q = NULL;
  while (p) {
    if (Hasher::IsEqual(p->Key(),K)) {
      Decrement();
      if (q) q->Next() = p->Next();
      else   data[k] = (TCollection_StdMapNode*) p->Next();
      delete p;
      return Standard_True;
    }
    q = p;
    p = (TCollection_StdMapNode*) p->Next();
  }
  return Standard_False;
}


// method of the iterator

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

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