programEngine.h

 
#ifndef PROGRAMENGINE_H
#define PROGRAMENGINE_H
 
#include "data/primitiveTypeArray.h"
#include "data/untypedSharedPtr.h"
#include "program/program.h"
 
namespace Program {
    class ProgramEngine
    {
      protected:
        const Program* program;
 
        ProgramEngine() = delete;
 
        Data::PrimitiveTypeArray<double>
            registers; // If the type of registers attribute is
                       // changed one day
        // make sure to update the Program::identifyIntrons()
        // method as it create its own
        // Data::PrimitiveTypeArray<double> to keep track of
        // accessed addresses.
 
        std::vector<std::reference_wrapper<const Data::DataHandler>>
            dataSources;
 
        std::vector<std::reference_wrapper<const Data::DataHandler>>
            dataScsConstsAndRegs;
 
        uint64_t programCounter;
 
      protected:
        ProgramEngine(const Environment& env)
            : programCounter{0}, registers{env.getParams().nbRegisters},
              program{NULL}, dataSources{env.getDataSources()}
        {
            // Setup the data sources
            dataScsConstsAndRegs.push_back(this->registers);
 
            if (env.getParams().nbProgramConstant > 0) {
                dataScsConstsAndRegs.push_back(env.getFakeDataSources().at(1));
            }
 
            // Cannot use insert here because it dataSourcesAndRegisters
            // requires constnessand dataSrc data are not const...
            for (auto data : env.getDataSources()) {
                dataScsConstsAndRegs.push_back(data.get());
            }
        }
 
        template <class T>
        ProgramEngine(const Program& prog,
                      const std::vector<std::reference_wrapper<T>>& dataSrc)
            : programCounter{0},
              registers{prog.getEnvironment().getParams().nbRegisters},
              program{NULL}
        {
            // Check that T is either convertible to a const DataHandler
            static_assert(
                std::is_convertible<T&, const Data::DataHandler&>::value);
            // Setup the data sources
            this->dataScsConstsAndRegs.push_back(this->registers);
 
            if (prog.getEnvironment().getParams().nbProgramConstant > 0) {
                this->dataScsConstsAndRegs.push_back(
                    prog.cGetConstantHandler());
            }
 
            // Cannot use insert here because it dataSourcesAndRegisters
            // requires constnessand dataSrc data are not const...
            for (std::reference_wrapper<T> data : dataSrc) {
                this->dataScsConstsAndRegs.push_back(data.get());
                this->dataSources.push_back(data.get());
            }
 
            // Set the Program
            this->setProgram(prog);
        };
 
        ProgramEngine(const Program& prog)
            : ProgramEngine(prog, prog.getEnvironment().getDataSources()){};
 
        virtual void processLine() = 0;
 
      public:
        void setProgram(const Program& prog);
 
        template <class T>
        void setDataSources(
            const std::vector<std::reference_wrapper<T>>& dataSrc);
 
        const std::vector<std::reference_wrapper<const Data::DataHandler>>&
        getDataSources() const;
 
        const bool next();
 
        const Line& getCurrentLine() const;
 
        const Instructions::Instruction& getCurrentInstruction() const;
 
        const void fetchCurrentOperands(
            std::vector<Data::UntypedSharedPtr>& operands) const;
 
        uint64_t getOperandLocation(uint64_t idxOp) const;
 
        virtual void iterateThroughtProgram(const bool ignoreException);
 
        virtual std::vector<double> getRegisterValues(uint64_t nbRegisters);
    };
 
    template <class T>
    inline void ProgramEngine::setDataSources(
        const std::vector<std::reference_wrapper<T>>& dataSrc)
    {
        // Check that T is either convertible to a const DataHandler
        static_assert(std::is_convertible<T&, const Data::DataHandler&>::value);
 
        // Replace the references in attributes
        this->dataSources = dataSrc;
        // we need this offset to push the constant at the first
        size_t offset =
            this->program->getEnvironment().getParams().nbProgramConstant > 0
                ? 2
                : 1;
        if (offset == 2) {
            this->dataScsConstsAndRegs.at(1) =
                this->program->cGetConstantHandler();
        }
        for (size_t idx = 0; idx < this->dataSources.size(); idx++) {
            this->dataScsConstsAndRegs.at(idx + offset) = dataSrc.at(idx);
        }
 
        // Set program to check compatibility with new data source
        this->setProgram(*this->program);
    }
} // namespace Program
 
#endif // PROGRAMENGINE_H