program.h

 
#ifndef PROGRAM_H
#define PROGRAM_H
 
#include <algorithm>
#include <vector>
 
#include "data/constantHandler.h"
#include "environment.h"
#include "program/line.h"
 
struct CounterReset;
 
namespace Program {
    class Program
    {
      protected:
        const Environment& environment;
 
        bool actionProgram;
 
        std::vector<std::pair<Line*, bool>> lines;
 
        Data::ConstantHandler constants;
 
        uint64_t programID;
 
        static uint64_t incrementeCounter();
 
        static void resetProgramIDCounter();
        friend struct ::CounterReset;
 
        Program() = delete;
 
      public:
        Program(const Environment& e, bool actProgram)
            : environment{e}, programID{incrementeCounter()},
              constants{e.getParams().nbProgramConstant},
              actionProgram{actProgram}
        {
            constants.resetData(); // force all constant to 0 at first.
        };
 
        Program(const Program& other)
            : environment{other.environment}, lines{other.lines},
              programID{other.programID}, constants{other.constants},
              actionProgram{other.actionProgram}
        {
            // Replace lines with their copy
            // Keep intron info
            std::transform(lines.begin(), lines.end(), lines.begin(),
                           [](std::pair<Line*, bool>& otherLine)
                               -> std::pair<Line*, bool> {
                               return {new Line(*(otherLine.first)),
                                       otherLine.second};
                           });
        };
 
        Program(const Program& other, bool actProgram)
            : environment{other.environment}, programID{incrementeCounter()},
              lines{other.lines}, constants{other.constants},
              actionProgram{actProgram}
        {
            // Replace lines with their copy
            // Keep intro info
            std::transform(lines.begin(), lines.end(), lines.begin(),
                           [](std::pair<Line*, bool>& otherLine)
                               -> std::pair<Line*, bool> {
                               return {new Line(*(otherLine.first)),
                                       otherLine.second};
                           });
        };
 
        Program& operator=(const Program& other) = delete;
 
        ~Program();
 
        Line& addNewLine();
 
        Line& addNewLine(const uint64_t idx);
 
        void addNewLine(Line newLine);
 
        void clearIntrons();
 
        void removeLine(const uint64_t idx);
 
        void swapLines(const uint64_t idx0, const uint64_t idx1);
 
        const Environment& getEnvironment() const;
 
        size_t getNbLines() const;
 
        const Line& getLine(uint64_t index) const;
 
        Line& getLine(uint64_t index);
 
        bool isIntron(uint64_t index) const;
 
        bool isActionProgram() const;
 
        uint64_t identifyIntrons();
 
        Data::ConstantHandler& getConstantHandler();
 
        const Data::ConstantHandler& cGetConstantHandler() const;
 
        const Data::Constant getConstantAt(size_t index) const;
 
        bool hasIdenticalBehavior(const Program& other) const;
 
        uint64_t getProgramID() const;
 
        virtual void setProgramID(uint64_t newID);
 
        static uint64_t getProgramIDCounter();
    };
} // namespace Program
#endif