initial revision

[lsystem3d.git] / src / rule.cpp

// Copyright (C) 2006 Erik Dahlberg
// 
// This file is part of LSystem3D.
// 
// LSystem3D 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.
// 
// LSystem3D 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 LSystem3D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA




#include <string>

#include <glibmm/stringutils.h>

#include "rule.h"

using namespace std;



/**
 * Constructor
 */
Rule::Rule()
{
    clear();
}



/**
 * Constructor
 * @param name name of rule
 * @param content content of rule
 * @param probability probability of rule
 */
Rule::Rule(string name, string content, double probability)
{
    setName(name);
    setContent(content);
    setProbability(probability);
}



/**
 * Constructor
 * @param ruleString the rule string
 */
Rule::Rule(string ruleString)
{
    fromString(ruleString);
}



/**
 * Destructor
 */
Rule::~Rule()
{
}



/**
 * Clear rule
 */
void Rule::clear()
{
    _name.clear();
    _content.clear();
    _probability = 0.0;
}



/**
 * Construct rule from string
 * @param ruleString the rule string
 */
void Rule::fromString(string ruleString)
{
    // name
    setName(ruleString.substr(0, 1));
    
    
    // probability factor
    
    int i = 2;
    
    if (ruleString[1] == '=')
    {
        // use default probability
        setProbability(1.0);
    }
    else if (ruleString[1] == '(')
    {
        // set probability
        while (ruleString[i] != ')')
        {
            i++;
        }
        setProbability(Glib::Ascii::strtod(string(ruleString, 2, i - 2)));
        
        // ignore the '='
        i += 2;
    }
    
    // content
    setContent(string(ruleString, i));
}



/**
 * Construct rule string
 * @return the rule string
 */
string Rule::toString()
{
    // name
    string rulesString = getName();
    
    
    // probability factor
    
    if (_probability != 0.0)
    {
        // TODO: precision
        string probabilityString(Glib::Ascii::dtostr(getProbability()), 0, 4);
        
        rulesString += '(';
        rulesString += probabilityString;
        rulesString += ')';
    }
    
    
    rulesString += '=';
    
    
    // content
    rulesString += getContent();
        
    
    return rulesString;
}



/**
 * Set rule name
 * @param name the name
 */
void Rule::setName(string name)
{
    _name = name;
}


    
/**
 * Set rule content
 * @param content the content
 */
void Rule::setContent(string content)
{
    string preprocessedRule;
    
    // preprocess the rule content
    for (int i = 0; i < content.size(); i++)
    {
        // TODO: allow string as name
        if (content[i] >= 'A' && content[i] <= 'Z' && content[i] != 'F')
        {
            // add rule operator
            preprocessedRule += '@';
        }
        preprocessedRule += content[i];
    }
    
    _content = preprocessedRule;
}



/**
 * Set rule probability
 * @param probability the probability factor
 */
void Rule::setProbability(double probability)
{
    if (probability >= 0 && probability <= 1)
    {
        _probability = probability;
    }
    else
    {
        probability = 0.0;
    }
}



/**
 * Get rule name
 * @return the rule name
 */
string Rule::getName()
{
    return _name;
}



/**
 * Get rule content
 * @return the rule content
 */
string Rule::getContent()
{
    string unpreprocessedRule;
    
    // unpreprocess the rule content
    for (int i = 0; i < _content.size(); i++)
    {
        if (_content[i] != '@')
        {
            unpreprocessedRule += _content[i];
        }
    }
    
    return unpreprocessedRule;
}

    
    
/**
 * Get rule probability
 * @return the probability
 */
double Rule::getProbability()
{
    return _probability;
}



/**
 * Get preprocessed content
 * @return the preprocessed content
 */
string Rule::getPreprocessedContent()
{
    return _content;
}