Changeset 26 for cpp/f8-to-f1

Timestamp:

06/29/09 22:12:09 (15 years ago)

Author:

mwajcht

Message:

Added some comments to converter classes

Location:

cpp/f8-to-f1

Files:

• conv_f8tof1.cpp (modified) (13 diffs)
• conv_f8tof1.h (modified) (11 diffs)

cpp/f8-to-f1/conv_f8tof1.cpp

@@ -366 +366 @@
         SString s = SString::valueOf(params[0]);
 #if CONV_DEBUG > 1
-        cout << "@@@@@ Wartosc parametru: " << this->paramName << ": " << params[0] << endl;
+        cout << "@@@@@ Param value: " << this->paramName << ": " << params[0] << endl;
 #endif
         return s;
@@ -414 +414 @@
 }
 
-/**
- * Zwracamy puste, bo co innego mamy zrobić?
- */
 const SString Production::getF1Genotype(const vector<double> params) {
-        return SString("");
+        return SString(); //return empty
 }
 
@@ -430 +427 @@
         }
         
-        //jedziemy po podprodukcjach
+        //iterate through subproductions
         for (vector<SubProduction>::iterator subProdIter = this->subproductions.begin();
                  subProdIter != this->subproductions.end(); subProdIter++) {
@@ -438 +435 @@
                 SubProduction &sp = *subProdIter;
                 bool conditionsOK = true;
-                //sprawdzenie warunków dla danej podprodukcji
+                //check conditions of subproduction
                 for (vector<Condition>::iterator condIter = sp.conditions.begin();
                          condIter != sp.conditions.end(); condIter++) {
                         if (conditionsOK == false) {
-                                break; //bo dalsze sprawdzanie i tak nie ma sensu
+                                break; //because it's no use checking further
                         }
                         Condition &c = *condIter;
@@ -479 +476 @@
                 }
                 if (conditionsOK) {
-                        //jedziemy po każdej akcji w danej podprodukcji
+                        //iterate through each action in subproduction
                         for (int i = 0; i < sp.actions.size(); i++) {
 #if CONV_DEBUG > 1
@@ -487 +484 @@
                                 vector<SString> strParams = sp.actions[i].params;
                                 vector<double> params;
-                                //podmieniamy nazwy parametrów na ich wartości
+                                //replace parameter names with values
                                 for (vector<SString>::iterator paramIter = strParams.begin();
                                          paramIter != strParams.end(); paramIter++) {
@@ -527 +524 @@
         while (in.getNextToken(pos, line, '\n')) {
 #if CONV_DEBUG > 1
-                std::cout << "### Linia: " << line << std::endl;
+                std::cout << "### Line: " << line << std::endl;
 #endif
                 if (line.startsWith("P") && line.indexOf('(', 0) == -1) {
@@ -540 +537 @@
                         SString prodName = line.substr(0, lParenIndex);
 #if CONV_DEBUG > 1
-                        std::cout << "###Produkcja: " << prodName << std::endl;
+                        std::cout << "###Production: " << prodName << std::endl;
 #endif
                         names.push_back(prodName);
@@ -599 +596 @@
         
         //cout << "convert() 1" << endl;
-        //ustawienie zmiennych dla początkowej produkcji
+        //set parameters for start production
         Production *firstProduction = lsystem->productions[lsystem->firstProductionName];
         vector<double> params;
@@ -674 +671 @@
         Lsystem *lsys = new Lsystem();
         
-        //wczytujemy nazwy produkcji i tworzymy wstępnie dla nich obiekty
+        //read production names and create objects for them
         vector<SString> names = this->readProductionNames(in);
         for (vector<SString>::iterator nameIter = names.begin(); nameIter != names.end(); nameIter++) {
@@ -699 +696 @@
 #if CONV_DEBUG > 1
         
-        cout << "@@@@@ Przeparsowane" << endl;
+        cout << "@@@@@ Parsed" << endl;
         
         cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << endl;
@@ -726 +723 @@
 
 bool GenoConv_F8ToF1::parseInput(const char* src, Lsystem* lsys) {
-        //inicjalizacja zmiennych parsera
+        //initialize parser
         int yv;
         istringstream input;
@@ -739 +736 @@
         extern YYSTYPE yylval;
         
-        //parsowanie wejścia
+        //parse input
         // on EOF yylex will return 0
         while((yv = scanner.yylex()) != 0) {

cpp/f8-to-f1/conv_f8tof1.h

@@ -43 +43 @@
 };
 
-class ActionP;
-
+class ActionP; //only declaration
+
+/// superclass of all actions, e.g. Production, PrimitiveProduction etc.
 class Action {
 public:
+        /// action's name
         SString name;
+        /// if true action should ignore params passed to it
         bool ignoreParams;
+        /// gets string representaion of this action in f1 format
         virtual const SString getF1Genotype(vector<double> params) = 0;
+        /// gets list of actions with double parameters to each of them
+        /// @param params parameters passed to this action
         virtual const list<ActionP> getActionList(const vector<double> params) = 0;
+        /// gets string representaion of this action in f8 format
         virtual const SString getF8Representation() = 0;
         virtual ~Action() {}
 };
 
+/// this class consists of pointer to some action and a list of parameters to that action;
+/// parameters are kept as strings
 class ActionStrP {
 public:
@@ -61 +70 @@
 };
 
+/// this class consists of pointer to some action and a list of parameters to that action;
+/// parameters are kept as doubles
 class ActionP {
 public:
@@ -67 +78 @@
 };
 
+/// part of production which is used in translation only if all the conditions are met
 class SubProduction {
 public:
+        /// list of conditions necessary to be met
         vector<Condition> conditions;
+        /// actions with params (as strings)
         vector<ActionStrP> actions;
 };
 
+/// primitive production; it's directly translated to its f1 equivalent
+/// e.g. X, r, R etc.
 class PrimitiveProduction : public Action {
 public:
@@ -84 +100 @@
 };
 
+/// param production; all param productions during translation are replaced with the current value of parameter
+/// pointed by this production
 class ParamProduction : public Action {
 public:
@@ -94 +112 @@
 };
 
+/// neuron production; it is directly translated to f1 without any change
 class NeuronProduction : public Action {
 public:
@@ -104 +123 @@
 };
 
-/**
- * Pozycje liczone od 1 a nie od 0!
- */
+/// class which keeps all parameters of a production and enables to access them in convenient way
+/// IMPORTANT! All indices (positions) begins with 1 (not 0)!
 class ParameterCollection {
 public:
+        /// returns parameter's value
+        /// @param position parameter's position (first parameter has an index 1!)
         const double getValue(int position);
+        /// returns parameter's value
+        /// @param name parameter's name
         const double getValue(SString name);
+        /// returns parameter's name
+        /// @param position parameter's position (first parameter has an index 1!)
         const SString getParameterName(int position);
-        const int getParameterPosition(SString name); //zwróci index liczony od 1!
+        /// returns parameter's position (first parameter has an index 1!)
+        /// @param name parameter's name
+        const int getParameterPosition(SString name);
+        /// sets parameter's value
+        /// @param position parameter's position
+        /// @param value parameter's new value
         void setValue(int position, double value);
+        /// sets parameter's value
+        /// @param name parameter's name
+        /// @param value parameter's new value
         void setValue(SString name, double value);
+        /// adds parameter
+        /// @param name parameter's name
+        /// @param position desired parameter's position; defualts to -1 which means it will have first available position
+        /// @param value parameter's value; defaults to 0.0
         void addParameter(SString name, int position = -1, double value = 0.0);
+        /// returns the number of parameters kept in this class
         const int size();
+        /// removes a parameter
+        /// @param position position of parameter to be deleted
         void removeParameter(int position);
+        /// removes a parameter
+        /// @param name name of parameter to be deleted
         void removeParameter(SString name);
+        /// returns true if parameter with given name exists
+        /// @param name parameter's name
         bool paramExist(SString name);
 protected:
@@ -125 +168 @@
 };
 
+/// represents a general rule in L-systems
+/// only "calls" to Production in genotype are replaced in translation procedure
 class Production : public Action {
 public:
+        /// parameters of this production
         ParameterCollection parameters;
+        /// list of subproductions
         vector<SubProduction> subproductions;
         
@@ -137 +184 @@
 };
 
+/// Main class that represents a genotype in f8 format
 class Lsystem {
 public:
+        /// number of iterations in f8->f1 translation procedure
         int iterations;
+        /// map of parameters of start production; key - parameter's name, value - parameter's value
         map<string, double> startParams;
+        /// map of productions of L-system; key - productions's name, value - pointer to production
         map<string, Production*> productions;
+        /// collection of neuron productions held in L-system
         vector<NeuronProduction*> neuronProductions;
+        /// first production's name
         string firstProductionName;
         
         Lsystem();
         ~Lsystem();
+        /// returns a primitive production of a given name
+        /// @param name primitive production's name
         PrimitiveProduction* getPrimitiveProduction(SString name);
+        /// returns a param production of a given name
+        /// @param name param production's name
         ParamProduction* getParamProduction(SString name);
+        /// gets string representation of this L-system (f8 genotype)
         SString toString();
+        /// returns all actions
+        /// @param normal if true all normal actions will be included
+        /// @param primitives if true all primitive actions will be included
+        /// @param params if true all param actions will be included
+        /// @param neurons if true all neuron actions will be included
         vector<Action*> getAllActions(bool normal, bool primitives, bool params, bool neurons);
 protected:
@@ -158 +221 @@
 };
 
+/// Converter between f8 and f1 format
 class GenoConv_F8ToF1 : public GenoConverter {
 public:
+        /// Default constructor
         GenoConv_F8ToF1() {
                 name = "f8 to f1 converter";
@@ -169 +234 @@
         }
         
+        /// Constructor with parameter
+        /// @param f1LengthLimit If resulting f1 genotype is longer than f1LengthLimit, converter aborts its job
         GenoConv_F8ToF1(int f1LengthLimit) {
                 name = "f8 to f1 converter";
@@ -181 +248 @@
         
         SString convert(SString &in, MultiMap *map);
+        
+        /// check syntax of given f8 genotype
+        /// @param geno f8 genotype to be checked
         bool checkSyntax(const char *geno);
+        
+        /// returns names of productions in a given genotype
+        /// @param in f8 genotype
         vector<SString> readProductionNames(const SString &in);
         //Lsystem* createLsystem(const SString &in);
+        
+        /// creates Lsystem object based on input genotype
+        /// @param f8 genotype
         Lsystem* createLsystem(SString in);
 protected: