source: cpp/f8-to-f1/conv_f8tof1.h @ 25

/*
 *  conv_f8tof1.h
 *  L-systemToF1
 *
 *  Created by Maciej Wajcht on 08-03-21.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */

#ifndef _CONV_F8_TO_F1_H
#define _CONV_F8_TO_F1_H

#include <map>
#include <vector>
#include <string>
#include <list>
#include <iostream>
#include "genoconv.h"
#include "model.h"

using std::ostream;
using std::vector;
using std::list;
using std::string;
using std::map;

enum RelationType {
        r_greater,
        r_greaterEqual,
        r_less,
        r_lessEqual,
        r_equal,
        r_different
};

class Condition {
public:
        RelationType relation;
        SString parameter;
        double value;
        
        friend ostream& operator<<(ostream& os, const Condition& c);
};

class ActionP;

class Action {
public:
        SString name;
        bool ignoreParams;
        virtual const SString getF1Genotype(vector<double> params) = 0;
        virtual const list<ActionP> getActionList(const vector<double> params) = 0;
        virtual const SString getF8Representation() = 0;
        virtual ~Action() {}
};

class ActionStrP {
public:
        Action *action;
        vector<SString> params;
};

class ActionP {
public:
        Action *action;
        vector<double> params;
};

class SubProduction {
public:
        vector<Condition> conditions;
        vector<ActionStrP> actions;
};

class PrimitiveProduction : public Action {
public:
        PrimitiveProduction(const SString command);
        const SString getF1Genotype(const vector<double> params);
        const list<ActionP> getActionList(const vector<double> params);
        const SString getF8Representation();
protected:
        SString f1command;
        SString f8command;
};

class ParamProduction : public Action {
public:
        ParamProduction(const SString paramName);
        const SString getF1Genotype(const vector<double> params);
        const list<ActionP> getActionList(const vector<double> params);
        const SString getF8Representation();
protected:
        SString paramName;
};

class NeuronProduction : public Action {
public:
        NeuronProduction(SString body);
        const SString getF1Genotype(const vector<double> params);
        const list<ActionP> getActionList(const vector<double> params);
        const SString getF8Representation();
protected:
        SString body;
};

/**
 * Pozycje liczone od 1 a nie od 0!
 */
class ParameterCollection {
public:
        const double getValue(int position);
        const double getValue(SString name);
        const SString getParameterName(int position);
        const int getParameterPosition(SString name); //zwróci index liczony od 1!
        void setValue(int position, double value);
        void setValue(SString name, double value);
        void addParameter(SString name, int position = -1, double value = 0.0);
        const int size();
        void removeParameter(int position);
        void removeParameter(SString name);
        bool paramExist(SString name);
protected:
        vector<string> parameters;
        map<string, double> paramValues;
};

class Production : public Action {
public:
        ParameterCollection parameters;
        vector<SubProduction> subproductions;
        
        Production();
        ~Production() {};
        const SString getF1Genotype(const vector<double> params);
        const list<ActionP> getActionList(const vector<double> params);
        const SString getF8Representation();
};

class Lsystem {
public:
        int iterations;
        map<string, double> startParams;
        map<string, Production*> productions;
        vector<NeuronProduction*> neuronProductions;
        string firstProductionName;
        
        Lsystem();
        ~Lsystem();
        PrimitiveProduction* getPrimitiveProduction(SString name);
        ParamProduction* getParamProduction(SString name);
        SString toString();
        vector<Action*> getAllActions(bool normal, bool primitives, bool params, bool neurons);
protected:
        map<string, PrimitiveProduction*> primitiveProductions;
        map<string, ParamProduction*> paramProductions;
        
        void removeEmptySubproductionsAndProductions();
};

class GenoConv_F8ToF1 : public GenoConverter {
public:
        GenoConv_F8ToF1() {
                name = "f8 to f1 converter";
                in_format = '8';
                out_format = '1';
                mapsupport = 0;
                info = "ble";
                maxF1Length = 500;
        }
        
        GenoConv_F8ToF1(int f1LengthLimit) {
                name = "f8 to f1 converter";
                in_format = '8';
                out_format = '1';
                mapsupport = 0;
                info = "ble";
                maxF1Length = f1LengthLimit;
        }
        
        ~GenoConv_F8ToF1() {}
        
        SString convert(SString &in, MultiMap *map);
        bool checkSyntax(const char *geno);
        vector<SString> readProductionNames(const SString &in);
        //Lsystem* createLsystem(const SString &in);
        Lsystem* createLsystem(SString in);
protected:
        bool parseInput(const char* src, Lsystem* lsys);
        int maxF1Length;
};

#endif