/home/enzo/treballs/fib/pfc/nanocomp/src/rule.cpp

Go to the documentation of this file.

/*
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
                                                                          */

// $Revision: 1.16 $

//TODO: check invalid combinations of Grids => initial cannot be the same as final

#include "rule.hpp"
#include <iostream>

using namespace std;


Rule::Rule(int width, int height)
    : initialGrid(width, height), finalGrid(width, height)
{
    this->height = height;
    this->width = width;
}


Rule::~Rule()
{
}



int Rule::getWidth()
{
    return width;
}



int Rule::getHeight()
{
    return height;
}



Grid Rule::getInitialGrid()
{
    return initialGrid;
}



Grid Rule::getFinalGrid()
{
    return finalGrid;
}



bool Rule::cellChanged(int x, int y, GridType layout)
{
    int status;
    Grid *grid;
    
    switch (layout)
    {
        case nINITIAL:
        {
            status = initialGrid(x, y);
            grid = &initialGrid;
            break;
        }
        case nFINAL:
        {
            status = finalGrid(x, y);
            grid = &finalGrid;
            break;
        }
    }
    
    switch (status)
    {
        case nENABLED:
        {
            (*grid)(x, y) = nDISABLED;
            break;
        }
        case nDISABLED:
        {
            (*grid)(x, y) = nDONTCARE;
            break;
        }
        case nDONTCARE:
        {
            (*grid)(x, y) = nENABLED;
            break;
        }
    }
    
    return true;
}



void Rule::setInitialGrid(Grid newGrid)
{
    initialGrid.init(newGrid);    
}



void Rule::setFinalGrid(Grid newGrid)
{
    finalGrid.init(newGrid);
}



bool Rule::cellChanged(int x, int y, int status, GridType layout)
{
    Grid *grid;
    switch (layout)
    {
        case nINITIAL:
        {
            grid = &initialGrid;
            break;
        }
        case nFINAL:
        {
            grid = &finalGrid;
            break;
        }
    }
    (*grid)(x, y) = status;
    
    return true;
}



bool Rule::equals(Rule *rule)
{
    if (getHeight() != rule->getHeight() || getWidth() != rule->getWidth())
    {
        return false;
    }
    Grid ruleInitialGrid = rule->getInitialGrid();
    Grid ruleFinalGrid = rule->getFinalGrid();
    for (int i = 0; i < getWidth(); i++)
    {
        for (int j = 0; j < getHeight(); j++)
        {
            if ((initialGrid(i, j) != ruleInitialGrid(i, j)) || (finalGrid(i, j) != ruleFinalGrid(i, j)))
            {
                return false;
            }
        }
    }
    return true;
}



bool Rule::sameInitialFinal()
{
    for (int i = 0; i < getWidth(); i++)
    {
        for (int j = 0; j < getHeight(); j++)
        {
            if ((initialGrid(i, j) != finalGrid(i, j)))
            {
                return false;
            }
        }
    }
    return true;
}



bool Rule::valid()
{
    for (int i = 0; i < getWidth(); i++)
    {
        for (int j = 0; j < getHeight(); j++)
        {
            if ((initialGrid(i, j) == nDONTCARE && (finalGrid(i, j) == nENABLED || finalGrid(i, j) == nDISABLED)))
            {
                return false;
            }
        }
    }
    return true;
}



matrix Rule::getInitialMatrix()
{
return initialGrid.getCells();
}



matrix Rule::getFinalMatrix()
{
    return finalGrid.getCells();
}



bool Rule::operator ==(Rule rule)
{
    return ((getWidth() == rule.getWidth()) && 
            (getHeight() == rule.getHeight()) && 
            (initialGrid == rule.getInitialGrid()) && 
            (finalGrid == rule.getFinalGrid()));
}

---