// This file is part of the Coriolis Project.
// Copyright (C) Laboratoire LIP6 - Departement ASIM
// Universite Pierre et Marie Curie
//
// Date : 29/01/2004
// Author : Hugo Clément <Hugo.Clement@lip6.fr>
#include <math.h>
#include "hurricane/Box.h"
#include "hurricane/DataBase.h"
#include "hurricane/Technology.h"
#include "hurricane/UpdateSession.h"
#include "crlcore/Utilities.h"
#include "crlcore/ToolBox.h"
#include "crlcore/CellGauge.h"
#include "crlcore/LefDefExtension.h"
#include "nimbus/GCell.h"
#include "nimbus/Fence.h"
#include "nimbus/VFence.h"
#include "nimbus/HFence.h"
#include "nimbus/StepProperty.h"
#include "nimbus/Grid.h"
#include "nimbus/NimbusEngine.h"
namespace Nimbus {
#define RG_HORIZONTAL 0
#define RG_VERTICAL 1
/*
* ********************************************************************
* GCell_GCells declaration
* ********************************************************************
*/
class Grid_GCells : public Collection<GCell*> {
public: typedef Collection<GCell*> Inherit;
public: class Locator : public Hurricane::Locator<GCell*> {
public: typedef Hurricane::Locator<GCell*> Inherit;
private: GCell* _nb;
private: unsigned _direction;
public: Locator(GCell* gcell = NULL);
public: Locator(const Locator& locator);
public: Locator& operator=(const Locator& locator);
public: virtual GCell* getElement() const;
public: virtual Hurricane::Locator<GCell*>* getClone() const;
public: virtual bool isValid() const;
public: virtual void progress();
public: virtual string _getString() const;
};
private: GCell* _nb;
private: unsigned _step;
public: Grid_GCells(const Grid* grid, unsigned step);
public: Grid_GCells(const Grid_GCells& gcelles);
public: Grid_GCells& operator=(const Grid_GCells& gcelles);
public: virtual Collection<GCell*>* getClone() const;
public: virtual Hurricane::Locator<GCell*>* getLocator() const;
public: virtual string _getString() const;
};
/*
* ********************************************************************
* GCell_GCells declaration
* ********************************************************************
*/
class Grid_FastGCells : public Collection<GCell*> {
public: typedef Collection<GCell*> Inherit;
public: class Locator : public Hurricane::Locator<GCell*> {
public: typedef Hurricane::Locator<GCell*> Inherit;
private: GCell* _nb;
private: unsigned _direction;
public: Locator(GCell* gcell = NULL);
public: Locator(const Locator& locator);
public: Locator& operator=(const Locator& locator);
public: virtual GCell* getElement() const;
public: virtual Hurricane::Locator<GCell*>* getClone() const;
public: virtual bool isValid() const;
public: virtual void progress();
public: virtual string _getString() const;
};
private: GCell* _nb;
private: unsigned _step;
public: Grid_FastGCells(const Grid* grid, unsigned step);
public: Grid_FastGCells(const Grid_FastGCells& gcelles);
public: Grid_FastGCells& operator=(const Grid_FastGCells& gcelles);
public: virtual Collection<GCell*>* getClone() const;
public: virtual Hurricane::Locator<GCell*>* getLocator() const;
public: virtual string _getString() const;
};
/*
* ********************************************************************
* Grid
*
* ********************************************************************
*/
Grid::Grid (NimbusEngine* nimbus)
//*******************************
: _nimbus (nimbus)
, _cell (nimbus->getCell())
, _rootGCell(NULL)
, _layer (NULL)
, _fences ()
{
_layer = DataBase::getDB()->getTechnology()->getLayer (Name ("SPL1"));
if ( _layer == NULL )
throw Error("NimbusEngine needs <SPL1> layer to be defined");
Box defBox = LefDefExtension::getRowsBox(_cell);
if ( not _nimbus->getWorkZone().isEmpty() ) {
_rootGCell = GCell::create(_nimbus, 0, _nimbus->getWorkZone());
} else if ( not defBox.isEmpty() ) {
UpdateSession::open();
if ( _cell->getAbutmentBox().isEmpty() )
_cell->setAbutmentBox ( defBox );
cmess1 << " - DEF abutment box found: " << defBox << endl;
_rootGCell = GCell::create(_nimbus, 0, defBox);
UpdateSession::close();
} else if ( _cell->getAbutmentBox().isEmpty() ) {
if ( isNoInstancePlacedOrFixed(_cell) ) {
DbU::Unit minWidth = DbU::Max;
double sumWidth = 0.0;
forEach ( Occurrence, ioccurrence, _cell->getLeafInstanceOccurrences() ) {
Instance* instance = static_cast<Instance*>((*ioccurrence).getEntity());
if ( not instance->isFixed() and instance->isTerminal() ) {
Cell* model = instance->getMasterCell();
sumWidth += DbU::getLambda(model->getAbutmentBox().getWidth());
}
}
// forEach ( Instance*, iinstance, _cell->getInstances() ) {
// Cell* model = iinstance->getMasterCell();
// DbU::Unit width = model->getAbutmentBox().getWidth();
// if ( width < minWidth ) minWidth = width;
// sumWidth += DbU::getLambda(width);
// }
rectangularShape(_nimbus->getMargin(), nimbus->getAspectRatio(), sumWidth, minWidth );
UpdateSession::open();
_cell->setAbutmentBox( Box ( _rootGCell->getXMin(), _rootGCell->getYMin()
, _rootGCell->getXMax(), _rootGCell->getYMax()) );
#if 0
Point center = box.getCenter();
forEach ( Instance*, iinstance, cell->getInstances() ) {
iinstance->setPlacementStatus ( Instance::PlacementStatus::PLACED );
setStep(**iinstance, 0);
Box insABox = iinstance->getAbutmentBox();
Box masterABox = iinstance->getMasterCell()->getAbutmentBox();
DbU::Unit xPos = center.getX();
DbU::Unit yPos = center.getY();
instance->setTransformation
( getTransformation ( masterABox
, xPos - insABox.getHalfWidth()
, yPos - insABox.getHalfHeight()
, Transformation::Orientation::ID
) );
}
#endif
UpdateSession::close();
} else {
Box box = _cell->getBoundingBox();
UpdateSession::open();
_cell->setAbutmentBox ( box );
_rootGCell = GCell::create(_nimbus, 0, box);
UpdateSession::close();
}
} else {
cmess1 << " - Design abutment box found: " << _cell->getAbutmentBox() << endl;
_rootGCell = GCell::create(_nimbus, 0, _cell->getAbutmentBox());
}
_rootGCell->setAsPlacementLeaf();
_rootGCell->setAsRoutingLeaf();
}
Grid::~Grid ()
//************
{
_rootGCell->destroy();
}
#if 0
void Grid::Clear()
// **************
{
_oldBoxes.clear();
_newBoxes.clear();
return;
}
#endif
void Grid::rectangularShape(double margin, double aspectRatio, double sumWidth, DbU::Unit minWidth)
// ************************************************************************************************
{
cmess1 << " o Creating abutment box: (margin:" << (margin*100.0)
<< "%, aspect ratio:" << (aspectRatio*100.0)
<< "%, sumWidth:" << sumWidth << ")" << endl;
double dMinWidth = DbU::getLambda(minWidth);
double rowHeight = DbU::getLambda(_nimbus->getSliceHeight());
DbU::Unit pitch = _nimbus->getPitch();
double marginWidth = (1.0+margin) * sumWidth;
// cerr << "sumWidth:" << sumWidth
// << " rowHeight:" << rowHeight
// << " pitch:" << DbU::getValueString(pitch)
// << " marginWidth:" << marginWidth
// << endl;
// AR = x/y S = x*y = marginWidth*SH x=S/y AR = S/y^2
// y = sqrt(S/AR)
double y = sqrt ( marginWidth*rowHeight / aspectRatio );
unsigned int rows = (unsigned int)(y / rowHeight);
if ( rows == 0 ) ++rows;
double rowWidth = marginWidth / rows;
// cerr << "y:" << y << " rows:" << rows << endl;
// cerr << "rowWidth:" << rowWidth << endl;
// cerr << "dMinWidth:" << dMinWidth << endl;
if ( (minWidth != DbU::Max) and (rowWidth < dMinWidth) ) {
rowWidth = dMinWidth;
rows = (unsigned int)(marginWidth / rowWidth);
if ( rows == 0 ) ++rows;
}
// cerr << "rowWidth:" << rowWidth << endl;
DbU::Unit unitRowWidth = DbU::lambda(rowWidth);
DbU::Unit adjustWidth = unitRowWidth % pitch;
if ( adjustWidth != 0 )
unitRowWidth += pitch - adjustWidth;
Box ab = Box ( 0, 0, unitRowWidth, rows * _nimbus->getSliceHeight() );
#if DEPRECATED
if ( nrows == 0 ) {
nrows = (int)(sqrt((1.0 + margin) * sumwidth / rowHeight) + 0.5);
}
DbU::Unit rowWidth
= DbU::lambda
( (int)((double)((int)((1.0 + margin) * DbU::getLambda(sumwidth)
/ ((double)nrows * DbU::getLambda(pitch)) ))
* DbU::getLambda(pitch) + 0.5)
);
Box ab = Box(0, 0, rowWidth, nrows * rowHeight);
#endif
cmess1 << " - Abutment box: " << ab << endl;
_rootGCell = GCell::create ( _nimbus, (unsigned)0, ab );
}
void Grid::horizontalLongSplit (unsigned step, DbU::Unit& Y) const
//***************************************************************
{
//Clear();
recLS (step, Y, RG_HORIZONTAL, _rootGCell);
return;
}
void Grid::verticalLongSplit (unsigned step, DbU::Unit& X) const
//*************************************************************
{
//Clear();
recLS (step, X, RG_VERTICAL, _rootGCell);
return;
}
void Grid::recLS (unsigned step, DbU::Unit& coord, unsigned direction, GCell* gcell) const
//*************************************************************************************
{
//cout << " recLS : " << step << "-" << gcell->getStep() << endl;
if (gcell->getStep() >= step) {
return;
}
if (gcell->getStep() == step - 1) {
if (!(gcell->hasSubGCells())) {
gcell->makeSub();
}
if (direction == RG_HORIZONTAL) {
//cout << "subHSplit" << endl;
gcell->subHSplit (coord);
//cout << "subHSplitted" << endl;
} else if (direction == RG_VERTICAL) {
//cout << "subVSplit" << endl;
gcell->subVSplit (coord);
//cout << "subVSplitted" << endl;
} else {
cerr << "Nothing to do here" << endl;
abort();
}
return;
} else { // exploration récursive
if (!(gcell->hasSubGCells())) {
gcell->makeSub();
}
for_each_gcell (nb, gcell->getSubGCells()) {
if (direction == RG_HORIZONTAL) {
if (
nb->horizontalIsCrossed (coord)
)
{
recLS (step, coord, direction, nb);
}
} else if (direction == RG_VERTICAL) {
if (
nb->verticalIsCrossed (coord)
)
{
recLS (step, coord, direction, nb);
}
} else {
cerr << "Nothing to do here" << endl;
abort();
}
end_for;
}
}
return;
}
Layer* Grid::getLayer () const {
return _layer;
}
GCell* Grid::recGetGCell (unsigned step, Point& p, GCell* gcell) const {
GCell* res = NULL;
if (! (gcell->contains(p))) {
return NULL;
}
if (gcell->getStep() == step) {
return gcell;
} else {
for_each_gcell (subBox, gcell->getSubGCells()) {
res = recGetGCell (step, p, subBox);
if (res)
break;
//return res;
end_for;
}
}
assert (res);
return res;
} // recGetGCell
GCell* Grid::getGCell (unsigned step, Point& p) const
{
return recGetGCell (step, p, _rootGCell);
}
const Box Grid::getBox (unsigned step, Point& p) const
{
GCell* gcell = getGCell (step, p);
return Box (gcell->getXMin(), gcell->getYMin(), gcell->getXMax(), gcell->getYMax());
}
Point Grid::getPosition (unsigned step, Point& pos) const
{
return (getGCell(step,pos)->getCenter());
}
DbU::Unit Grid::getX (unsigned step, DbU::Unit& X) const
{
Point p = Point (X, DbU::lambda (0));
return getGCell (step, p)->getXCenter();
}
DbU::Unit Grid::getY (unsigned step, DbU::Unit& Y) const
{
Point p = Point (DbU::lambda (0), Y);
return getGCell (step, p)->getYCenter();
}
void Grid::recDumpGrid (GCell* gcell) const{
cout << " Step : " << gcell->getStep() << endl;
gcell->dumpPavement();
for_each_gcell (subBox, gcell->getSubGCells()) {
recDumpGrid(subBox);
end_for;
}
return;
}
void Grid::dumpGrid () const{
cout << " o dumping grid..." << endl;
recDumpGrid (_rootGCell);
cout << " - grid dumped." << endl;
return;
}
/*
* ********************************************************************
* Collection des boites du niveau step
*/
GCells Grid::getGCells (unsigned step) const
{
return Grid_GCells(this, step);
}
GCells Grid::getFastGCells (unsigned step) const
{
return Grid_FastGCells(this, step);
}
/*
* ********************************************************************
*
* Création des Frontières
*/
void Grid::createFences (unsigned step)
{
_fences[step] = new FenceSet();
for_each_gcell (gcell, getGCells(step)) {
//cmess1 << gcell << endl;
if (!gcell->getLeftFence()) {
GCell* nbleft = gcell->computeLeftOfMe();
if (nbleft) {
Fence* fence = static_cast<Fence*> (VFence::create (this, nbleft, gcell));
gcell->getContainer()->addInnerFence(fence);
fence->setStep(step);
_fences[step]->_insert(fence);
}
}
if (!gcell->getRightFence()) {
GCell* nbright = gcell->computeRightOfMe();
if (nbright) {
Fence* fence = static_cast<Fence*> (VFence::create (this, gcell, nbright));
gcell->getContainer()->addInnerFence(fence);
fence->setStep(step);
_fences[step]->_insert(fence);
}
}
if (!gcell->getUpFence()) {
GCell* nbup = gcell->computeUpOfMe();
if (nbup) {
Fence* fence = static_cast<Fence*> (HFence::create (this, nbup, gcell));
gcell->getContainer()->addInnerFence(fence);
fence->setStep(step);
_fences[step]->_insert(fence);
}
}
if (!gcell->getDownFence()) {
GCell* nbdown = gcell->computeDownOfMe();
if (nbdown) {
Fence* fence = static_cast<Fence*> (HFence::create (this, gcell, nbdown));
gcell->getContainer()->addInnerFence(fence);
fence->setStep(step);
_fences[step]->_insert(fence);
}
}
end_for;
}
return;
}
/*
* ********************************************************************
*
* Collection des frontieres pour un niveau
*/
Fences Grid::getFences (unsigned step)
{
return _fences[step]->getElements();
}
Fence* Grid::getFenceBetween (GCell* nb1, GCell* nb2) const
{
Fence* fence = testFenceBetween (nb1, nb2);
if (!fence)
{
cerr << "no fence between " << nb1 << " and " << nb2 << "." << endl;
abort();
throw Error ("getFenceBetween : gcelles are not linked together");
}
return fence;
}
Fence* Grid::testFenceBetween (GCell* nb1, GCell* nb2) const
{
if (nb1 == nb2)
{
return NULL;
#if 0
abort();
throw Error ("getFenceBetween : same gcelles");
#endif
}
if (nb1->getStep() != nb2->getStep())
{
return NULL;
#if 0
abort();
throw Error ("getFenceBetween : gcelles from different grid levels");
#endif
}
for_each_fence (fence, nb1->getSurroundingFences())
{
if (fence->getOppositeGCell (nb1) == nb2)
return fence;
end_for;
}
return NULL;
}
// Compat
Grid* Grid::create (unsigned n, DbU::Unit& width, DbU::Unit& height) {
throw Error ("Nimbus: Grid: entering an outdated and deactivated function");
return NULL;
}
Box Grid::getGRBox (unsigned step, Point& p) {
return (getBox (step, p));
}
Contact* Grid::getContact (Net& net, Point& position) {
for_each_contact (contact, net.getContacts()) {
if (contact->getPosition() == position) {
return contact;
} else {
// vide
}
end_for;
}
return NULL;
}
Contact* Grid::getOrCreateContact (Net& net, Point& position, DbU::Unit width, DbU::Unit height) {
Contact* c = NULL;
c = getContact (net, position);
if (!c)
c = Contact::create (&net, getLayer(), position.getX(), position.getY(), width, height);
return c;
}
#if 0
Contact* Grid::getOrCreateContact (Net& net, Point& position) {
Contact* c = NULL;
c = getContact (net, position);
if (!c)
c = Contact::create (&net, getLayer(), position.getX(), position.getY(), DbU::lambda(5), DbU::lambda(5));
return c;
}
#endif
DbU::Unit Grid::getVSplitterHalfLength (unsigned step) {
return DbU::lambda (2);
}
DbU::Unit Grid::getHSplitterHalfLength (unsigned step) {
return DbU::lambda (2);
}
Point Grid::getSubUpLeft (unsigned step, Point& pos) {
GCell* gcell = getGCell (step, pos);
return gcell->getSubUpperLeft()->getCenter();
}
Point Grid::getSubUpRight (unsigned step, Point& pos) {
GCell* gcell = getGCell (step, pos);
assert (gcell);
assert (gcell->getSubUpperRight());
return gcell->getSubUpperRight()->getCenter();
}
Point Grid::getSubDownLeft (unsigned step, Point& pos) {
GCell* gcell = getGCell (step, pos);
return gcell->getSubBottomLeft()->getCenter();
}
Point Grid::getSubDownRight (unsigned step, Point& pos) {
GCell* gcell = getGCell (step, pos);
return gcell->getSubBottomRight()->getCenter();
}
GCell* Grid::getLeftOf (const GCell* gcell) const
{
GCell* nbl = gcell->getLeftOfMe();
if (!nbl) nbl = gcell->computeLeftOfMe();
return nbl;
}
GCell* Grid::getRightOf (const GCell* gcell) const
{
GCell* nbr = gcell->getRightOfMe();
if (!nbr) nbr = gcell->computeRightOfMe();
return nbr;
}
GCell* Grid::getUpOf (const GCell* gcell) const
{
GCell* nbu = gcell->getUpOfMe();
if (!nbu) nbu = gcell->computeUpOfMe();
return nbu;
}
GCell* Grid::getDownOf (const GCell* gcell) const
{
GCell* nbd = gcell->getDownOfMe();
if (!nbd) nbd = gcell->computeDownOfMe();
return nbd;
}
GCell* Grid::getUpperLeftCorner (unsigned step) const
{
GCell* gcell = getRoot();
for (unsigned level = 0 ; level < step ; level++) {
gcell = gcell->getSubUpperLeft();
if (!gcell) throw Error ("Nimbus crushed when diving too deep.");
}
return gcell;
}
GCell* Grid::getUpperRightCorner (unsigned step) const
{
GCell* gcell = getRoot();
for (unsigned level = 0 ; level < step ; level++) {
gcell = gcell->getSubUpperRight();
if (!gcell) throw Error ("Nimbus crushed when diving too deep.");
}
return gcell;
}
GCell* Grid::getLowerLeftCorner (unsigned step) const
{
GCell* gcell = getRoot();
for (unsigned level = 0 ; level < step ; level++) {
gcell = gcell->getSubLowerLeft();
if (!gcell) throw Error ("Nimbus crushed when diving too deep.");
}
return gcell;
}
GCell* Grid::getLowerRightCorner (unsigned step) const
{
GCell* gcell = getRoot();
for (unsigned level = 0 ; level < step ; level++) {
gcell = gcell->getSubLowerRight();
if (!gcell) throw Error ("Nimbus crushed when diving too deep.");
}
return gcell;
}
/*
* ********************************************************************
*
* Grid_GCells implementation
*/
Grid_GCells::Grid_GCells(const Grid* grid, unsigned step)
// ************************************************************************
: Inherit()
, _nb(NULL)
, _step(step)
{
_nb = grid->getRoot();
for (unsigned level = 0 ; level < step ; level++) {
_nb = _nb->getSubUpperLeft();
if (!_nb) throw Error ("Nimbus crushed when diving too deep.");
}
}
Grid_GCells::Grid_GCells(const Grid_GCells& gcelles)
// ************************************************************************
: Inherit()
, _nb(gcelles._nb)
, _step(gcelles._step)
{
}
Grid_GCells& Grid_GCells::operator=(const Grid_GCells& gcelles)
// ***********************************************************************************
{
_nb = gcelles._nb;
_step = gcelles._step;
return *this;
}
Collection<GCell*>* Grid_GCells::getClone() const
// ***********************************************
{
return new Grid_GCells(*this);
}
Locator<GCell*>* Grid_GCells::getLocator() const
// ******************************************************
{
return new Locator(_nb);
}
string Grid_GCells::_getString() const
// *************************************
{
string s = "<" + _TName("GCell::GCells");
if (_nb) s += " " + getString(_nb);
s += ">";
return s;
}
/*
* ********************************************************************
* Grid_GCells::Locator implementation
*/
Grid_GCells::Locator::Locator(GCell* gcell)
// ********************************************************
: Inherit(),
_nb(gcell),
_direction(0)
{
}
Grid_GCells::Locator::Locator(const Locator& locator)
// ****************************************************
: Inherit(),
_nb(locator._nb),
_direction(locator._direction)
{
}
Grid_GCells::Locator& Grid_GCells::Locator::operator=(const Locator& locator)
// ******************************************************************************
{
_nb = locator._nb;
_direction = locator._direction;
return *this;
}
GCell* Grid_GCells::Locator::getElement() const
// *********************************************
{
return _nb;
}
Locator<GCell*>* Grid_GCells::Locator::getClone() const
// *****************************************************
{
return new Locator(*this);
}
bool Grid_GCells::Locator::isValid() const
// *****************************************
{
return (_nb != NULL);
}
void Grid_GCells::Locator::progress()
// ************************************
{
GCell* gcell = NULL;
switch (_direction) {
case 0:
gcell = _nb->computeRightOfMe();
if (!gcell) {
gcell = _nb->computeDownOfMe();
_direction = 1;
}
break;
case 1:
gcell = _nb->computeLeftOfMe();
if (!gcell) {
gcell = _nb->computeDownOfMe();
_direction = 0;
}
break;
default:
gcell = NULL;
break;
}
_nb = gcell;
}
string Grid_GCells::Locator::_getString() const
// **********************************************
{
string s = "<" + _TName("GCells::GCells::Locator");
if (_nb) s += " " + getString(_nb);
s += ">";
return s;
}
/*
* ********************************************************************
* Grid_FastGCells implementation
*/
Grid_FastGCells::Grid_FastGCells(const Grid* grid, unsigned step)
// **************************************************************************************
: Inherit()
, _nb(NULL)
, _step(step)
{
_nb = grid->getRoot();
for (unsigned level = 0 ; level < step ; level++) {
_nb = _nb->getSubUpperLeft();
if (!_nb) throw Error ("Nimbus crushed when diving too deep.");
}
}
Grid_FastGCells::Grid_FastGCells(const Grid_FastGCells& gcelles)
// ************************************************************************************
: Inherit()
, _nb(gcelles._nb)
, _step(gcelles._step)
{
}
Grid_FastGCells& Grid_FastGCells::operator=(const Grid_FastGCells& gcelles)
// ****************************************************************
{
_nb = gcelles._nb;
_step = gcelles._step;
return *this;
}
Collection<GCell*>* Grid_FastGCells::getClone() const
// ***********************************************
{
return new Grid_FastGCells(*this);
}
Locator<GCell*>* Grid_FastGCells::getLocator() const
// **********************************************
{
return new Locator(_nb);
}
string Grid_FastGCells::_getString() const
// *************************************
{
string s = "<" + _TName("GCell::GCells");
if (_nb) s += " " + getString(_nb);
s += ">";
return s;
}
/*
* ********************************************************************
* Grid_FastGCells::Locator implementation
*/
Grid_FastGCells::Locator::Locator(GCell* gcell)
// ********************************************************
: Inherit(),
_nb(gcell),
_direction(0)
{
}
Grid_FastGCells::Locator::Locator(const Locator& locator)
// ****************************************************
: Inherit(),
_nb(locator._nb),
_direction(locator._direction)
{
}
Grid_FastGCells::Locator& Grid_FastGCells::Locator::operator=(const Locator& locator)
// ******************************************************************************
{
_nb = locator._nb;
_direction = locator._direction;
return *this;
}
GCell* Grid_FastGCells::Locator::getElement() const
// *********************************************************
{
return _nb;
}
Locator<GCell*>* Grid_FastGCells::Locator::getClone() const
// *****************************************************************
{
return new Locator(*this);
}
bool Grid_FastGCells::Locator::isValid() const
// **************************************************
{
return (_nb != NULL);
}
void Grid_FastGCells::Locator::progress()
// *********************************************
{
GCell* gcell = NULL;
switch (_direction) {
case 0:
gcell = _nb->getRightOfMe();
if (!gcell) {
gcell = _nb->getDownOfMe();
_direction = 1;
}
break;
case 1:
gcell = _nb->getLeftOfMe();
if (!gcell) {
gcell = _nb->getDownOfMe();
_direction = 0;
}
break;
default:
gcell = NULL;
break;
}
_nb = gcell;
}
string Grid_FastGCells::Locator::_getString() const
// *******************************************************
{
string s = "<" + _TName("Grid::FastGCells::Locator");
if (_nb) s += " " + getString(_nb);
s += ">";
return s;
}
#if 0
/*
* ********************************************************************
* Grid_Fences implementation
*/
Grid_Fences::Grid_Fences(const Grid* grid, unsigned step)
// **************************************************************************************
: Inherit()
, _nb(NULL)
, _fence(NULL)
, _step(step)
{
_nb = grid->getRoot();
for (unsigned level = 0 ; level < step ; level++) {
_nb = _nb->getSubUpperLeft();
if (!_nb) throw Error ("Nimbus crushed while diving too deep.");
}
}
Grid_Fences::Grid_Fences(const Grid_Fences& fences)
// ************************************************************************************
: Inherit()
, _nb(fences._nb)
, _fence(fences._nb)
, _step(fences._step)
{
}
Grid_Fences& Grid_Fences::operator=(const Grid_Fences& fences)
// ****************************************************************
{
_nb = ._nb;
_step = ._step;
return *this;
}
Collection<Fence*>* Grid_Fences::getClone() const
// ***********************************************
{
return new Grid_Fences(*this);
}
Locator<Fence*>* Grid_Fences::getLocator() const
// **********************************************
{
return new Locator(_nb);
}
string Grid_Fences::_getString() const
// *************************************
{
string s = "<" + _TName("Fence::Fencees");
if (_nb) s += " " + getString(_nb);
s += ">";
return s;
}
/*
* ********************************************************************
* Grid_Fences::Locator implementation
*/
Grid_Fences::Locator::Locator(Fence* gcell)
// ********************************************************
: Inherit(),
_nb(gcell),
_direction(0)
{
}
Grid_Fences::Locator::Locator(const Locator& locator)
// ****************************************************
: Inherit(),
_nb(locator._nb),
_direction(locator._direction)
{
}
Grid_Fences::Locator& Grid_Fences::Locator::operator=(const Locator& locator)
// ******************************************************************************
{
_nb = locator._nb;
_direction = locator._direction;
return *this;
}
Fence* Grid_Fences::Locator::getElement() const
// *********************************************************
{
return _nb;
}
Locator<Fence*>* Grid_Fences::Locator::getClone() const
// *****************************************************************
{
return new Locator(*this);
}
bool Grid_Fences::Locator::isValid() const
// **************************************************
{
return (_nb != NULL);
}
void Grid_Fences::Locator::progress()
// *********************************************
{
Fence* gcell = NULL;
switch (_direction) {
case 0:
gcell = _nb->getLeftOfMe();
if (!gcell) {
gcell = _nb->getDownOfMe();
_direction = 1;
}
break;
case 1:
gcell = _nb->getRightOfMe();
if (!gcell) {
gcell = _nb->getDownOfMe();
_direction = 0;
}
break;
default:
gcell = NULL;
break;
}
_nb = gcell;
}
string Grid_Fences::Locator::_getString() const
// *******************************************************
{
string s = "<" + _TName("Grid::FastFencees::Locator");
if (_nb) s += " " + getString(_nb);
s += ">";
return s;
}
#endif
/*
* FenceSet implementation
*
*/
Grid::FenceSet::FenceSet()
// **********************
: Inherit()
{
}
unsigned Grid::FenceSet::_getHashValue(Fence* fence) const
{
return ( (unsigned int)( (unsigned long)fence ) ) / 2;
}
Fence* Grid::FenceSet::_getNextElement(Fence* fence) const
{
return fence->_getNextOfGridFenceSet();
}
void Grid::FenceSet::_setNextElement(Fence* fence, Fence* nextFence) const
{
fence->_setNextOfGridFenceSet(nextFence);
return;
}
}