abstractfile.h

Go to the documentation of this file.

#ifndef ABSTRACTFILE_H_
#define ABSTRACTFILE_H_

#include <string>
#include <vector>
#include <map>
#include "configuration.h"
#include "lsystemexception.h"

using std::string;

namespace AP_LSystem {
class AbstractFile
{
protected:
    unsigned int m_Type;                    
    string m_Name;                          
    string m_Axiom;                         

    std::vector<string> m_Rules;            
    std::vector<string> m_Homomorphisms;    
    std::vector<string> m_Subsytems;        

    void addType( std::string & type )
    {
        if(type == "0L")
        {
            m_Type |= LS_0L;
        }
        else if(type == "1LL")
        {
            m_Type |= LS_1LL;
        }
        else if(type == "1LR")
        {
            m_Type |= LS_1LR;
        }
        else if(type == "2L")
        {
            m_Type |= LS_2L;
        }
        else if(type == "IL")
        {
            m_Type |= LS_IL;
        }
        else if(type == "DETERMINISTIC")
        {
            m_Type |= LS_DETERMINISTIC;
        }
        else if(type == "STOCHASTIC")
        {
            m_Type |= LS_STOCHASTIC;
        }
        else if(type == "PARAMETRIC")
        {
            m_Type |= LS_PARAMETRIC;
        }
        else
        {
            throw ParsingException("unknown lsystem type");
        }
    }
public:
    AbstractFile(): m_Type(0){}

    virtual void open( std::string & filename) = 0;

    void substitute(std::map<string, string> & pairs)
    {
        unsigned int i;
        std::vector<string>::iterator rule;
        std::map<std::string,std::string>::iterator subst;

        // substitute occurences in m_Axiom
        for(subst = pairs.begin(); subst != pairs.end(); subst++)
        {
            i=0;
            while((i = m_Axiom.find(subst->first,i))&&(i != std::string::npos))
            {
                m_Axiom.replace(i,subst->first.length(),subst->second);
                i += subst->second.length();
            }
        }

        // substitute occurences in m_Rules
        for(rule = m_Rules.begin();rule != m_Rules.end(); rule++)
        {
            for(subst = pairs.begin(); subst != pairs.end(); subst++)
            {
                i=0;
                while((i = rule->find(subst->first,i))&&(i != std::string::npos))
                {
                    rule->replace(i,subst->first.length(),subst->second);
                    i += subst->second.length();
                }
            }
        }

        for(rule = m_Homomorphisms.begin();rule != m_Homomorphisms.end(); rule++)
        {
            for(subst = pairs.begin(); subst != pairs.end(); subst++)
            {
                i=0;
                while((i = rule->find(subst->first,i))&&(i != std::string::npos))
                {
                    rule->replace(i,subst->first.length(),subst->second);
                    i += subst->second.length();
                }
            }
        }
    }

    virtual std::vector<string> * getHomomorphisms()
    {
        return &m_Homomorphisms;
    }

    virtual std::vector<string> * getRules()
    {
        return &m_Rules;
    }

    virtual std::vector<string> * getSubsystems()
    {
        return &m_Subsytems;
    }

    std::string & getAxiom()
    {
        return m_Axiom;
    }

    unsigned int type()
    {
        return m_Type;
    }

    std::string & name()
    {
        return m_Name;
    }
};
}

#endif // ABSTRACTFILE_H