GeneralNumModelModifier.h

Go to the documentation of this file.

#ifndef GENERAL_NUM_MODEL_MODIFIER_H
#define GENERAL_NUM_MODEL_MODIFIER_H
 
#include <map>
#include <string>
#include <unordered_map>
 
#include "ModelModifier.h"
#include "Extractor.h"
#include "Interpreter.h"
#include "SMParamSetter.h"
#include "ParamWriter.h"
#include "IncludeManager.hpp"
#include "LineProcessor.h"
#include "ModelWriter.h"
#include "MartyFileWriter.h"
#include "FileNameManager.h"
 
class GeneralNumModelModifier {
private:
    std::string wilson;     
    std::string model;      
    bool bsm_split_generation{false}; 
    bool full_target_generation{false}; 
    bool forceMode; 
    
    Interpreter                 interpreter;
    std::unique_ptr<SMParamSetter> paramSetter;
    MartyFileWriter                  fileWriter;
    LineProcessor               lineProcessor;
    ModelWriter                 modelWriter;
    ParamWriter                 paramWriter;
    IncludeManager              includeManager;
    
    std::map<std::string, std::string> paramMap;
 
    std::unordered_map<std::string, double> params;
 
    std::unordered_map<std::string, InterpretedParam> interpreted_params;
 
 
public:
    GeneralNumModelModifier(const std::string& wilson,
                            const std::string& model,
                            std::unique_ptr<SMParamSetter> param_setter,
                            std::shared_ptr<ICoreAPI<Model>> api,
                            std::shared_ptr<IInterpreterPortsFactory> ports,
                            bool force = false)
        : GeneralNumModelModifier(wilson, model, model, std::move(param_setter), std::move(api), std::move(ports), force, false, false)
    {}
 
    GeneralNumModelModifier(const std::string& wilson,
                            const std::string& model,
                            const std::string& mapping_model,
                            std::unique_ptr<SMParamSetter> param_setter,
                            std::shared_ptr<ICoreAPI<Model>> api,
                            std::shared_ptr<IInterpreterPortsFactory> ports,
                            bool force = false,
                            bool bsm_split_generation = false,
                            bool full_target_generation = false)
        : wilson(wilson),
          model(model),
          bsm_split_generation(bsm_split_generation),
          full_target_generation(full_target_generation),
          forceMode(force),
          interpreter(mapping_model, api, ports),
          paramSetter(std::move(param_setter)),
          fileWriter(wilson, model, bsm_split_generation, full_target_generation),
          lineProcessor(includeManager, fileWriter, force),
          modelWriter(lineProcessor, paramWriter) {
        initializeParams();
    }
 
    inline GeneralNumModelModifier(const GeneralNumModelModifier& other)
    : wilson(other.wilson),
      model(other.model),
      bsm_split_generation(other.bsm_split_generation),
      full_target_generation(other.full_target_generation),
      forceMode(other.forceMode),
      interpreter(other.interpreter),
      paramSetter(other.paramSetter ? std::make_unique<SMParamSetter>(*other.paramSetter) : nullptr),
      fileWriter(other.wilson, other.model, other.bsm_split_generation, other.full_target_generation),
      lineProcessor(includeManager, fileWriter, other.forceMode),
      modelWriter(lineProcessor, paramWriter),
      paramWriter(other.paramWriter),
      includeManager(other.includeManager),
      paramMap(other.paramMap),
      params(other.params),
      interpreted_params(other.interpreted_params)
{}
 
    void modify(std::ifstream& inputFile, std::ofstream& outputFile);
 
    void createparamfile(std::ofstream& paramFile, const std::unordered_map<std::string, double> &params);
 
    std::unordered_map<std::string, InterpretedParam> get_interpreted_param_map() { return this->interpreted_params; }
 
    std::unordered_map<std::string, double> get_params() {return this->params;}
private:
    void initializeParams();
};
 
#endif  // GENERAL_NUM_MODEL_MODIFIER_H