implement oms_duplicateVariant() (#1178)

arun3688 · web-flow · commit e07f46c6b377 · 2022-07-21T11:21:02.000+02:00
* implement oms_duplicateVariant()

* assign unique signalFilter.xml names for variants

* expected output

* add test to filter signals in variants

* create unique filename for local resources (.ssv,.ssm) when duplicating variants

* fix variantNames for subsystems

* fix handling variantNames
diff --git a/src/OMSimulatorLib/Component.h b/src/OMSimulatorLib/Component.h
@@ -63,7 +63,7 @@ namespace oms
     virtual ~Component();
 
     virtual oms_status_enu_t addSignalsToResults(const char* regex) = 0;
-    virtual oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const = 0;
+    virtual oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const = 0;
     virtual oms_status_enu_t exportToSSV(pugi::xml_node& ssvNode) { return logError_NotImplemented; }
     virtual void getFilteredUnitDefinitionsToSSD(std::map<std::string, std::map<std::string, std::string>>& unitDefinitions) { return ; }
 
diff --git a/src/OMSimulatorLib/ComponentFMUCS.cpp b/src/OMSimulatorLib/ComponentFMUCS.cpp
@@ -366,7 +366,7 @@ oms::Component* oms::ComponentFMUCS::NewComponent(const pugi::xml_node& node, om
   return component;
 }
 
-oms_status_enu_t oms::ComponentFMUCS::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const
+oms_status_enu_t oms::ComponentFMUCS::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const
 {
 #if !defined(NO_TLM)
   if (tlmbusconnectors[0])
@@ -394,7 +394,7 @@ oms_status_enu_t oms::ComponentFMUCS::exportToSSD(pugi::xml_node& node, Snapshot
         return oms_status_error;
 
   // export ParameterBindings at component level
-  values.exportParameterBindings(node, snapshot);
+  values.exportParameterBindings(node, snapshot, variantName);
 
   return oms_status_ok;
 }
diff --git a/src/OMSimulatorLib/ComponentFMUCS.h b/src/OMSimulatorLib/ComponentFMUCS.h
@@ -60,7 +60,7 @@ namespace oms
     static Component* NewComponent(const pugi::xml_node& node, System* parentSystem, const std::string& sspVersion, const Snapshot& snapshot);
     const FMUInfo* getFMUInfo() const {return &(this->fmuInfo);}
 
-    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const;
+    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const;
     oms_status_enu_t exportToSSV(pugi::xml_node& ssvNode);
     void getFilteredUnitDefinitionsToSSD(std::map<std::string, std::map<std::string, std::string>>& unitDefinitions);
     oms_status_enu_t exportToSSVTemplate(pugi::xml_node& ssvNode, Snapshot& snapshot);
diff --git a/src/OMSimulatorLib/ComponentFMUME.cpp b/src/OMSimulatorLib/ComponentFMUME.cpp
@@ -367,7 +367,7 @@ oms::Component* oms::ComponentFMUME::NewComponent(const pugi::xml_node& node, om
   return component;
 }
 
-oms_status_enu_t oms::ComponentFMUME::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const
+oms_status_enu_t oms::ComponentFMUME::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const
 {
 #if !defined(NO_TLM)
   if (tlmbusconnectors[0])
@@ -395,7 +395,7 @@ oms_status_enu_t oms::ComponentFMUME::exportToSSD(pugi::xml_node& node, Snapshot
         return oms_status_error;
 
   // export ParameterBindings at component level
-  values.exportParameterBindings(node, snapshot);
+  values.exportParameterBindings(node, snapshot, variantName);
 
   return oms_status_ok;
 }
diff --git a/src/OMSimulatorLib/ComponentFMUME.h b/src/OMSimulatorLib/ComponentFMUME.h
@@ -57,7 +57,7 @@ namespace oms
     static Component* NewComponent(const pugi::xml_node& node, System* parentSystem,  const std::string& sspVersion, const Snapshot& snapshot);
     const FMUInfo* getFMUInfo() const {return &(this->fmuInfo);}
 
-    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const;
+    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const;
     oms_status_enu_t exportToSSV(pugi::xml_node& ssvNode);
     void getFilteredUnitDefinitionsToSSD(std::map<std::string, std::map<std::string, std::string>>& unitDefinitions);
     oms_status_enu_t exportToSSVTemplate(pugi::xml_node& ssvNode, Snapshot& snapshot);
diff --git a/src/OMSimulatorLib/ComponentTable.cpp b/src/OMSimulatorLib/ComponentTable.cpp
@@ -161,7 +161,7 @@ oms::Component* oms::ComponentTable::NewComponent(const pugi::xml_node& node, om
   return component;
 }
 
-oms_status_enu_t oms::ComponentTable::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const
+oms_status_enu_t oms::ComponentTable::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const
 {
   node.append_attribute("name") = this->getCref().c_str();
   node.append_attribute("type") = "application/table";
diff --git a/src/OMSimulatorLib/ComponentTable.h b/src/OMSimulatorLib/ComponentTable.h
@@ -55,7 +55,7 @@ namespace oms
     static Component* NewComponent(const oms::ComRef& cref, System* parentSystem, const std::string& path);
     static Component* NewComponent(const pugi::xml_node& node, System* parentSystem, const std::string& sspVersion, const Snapshot& snapshot);
 
-    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const;
+    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const;
     oms_status_enu_t exportToSSVTemplate(pugi::xml_node& ssvNode) {return oms_status_ok;}
     oms_status_enu_t exportToSSMTemplate(pugi::xml_node& ssmNode) {return oms_status_ok;}
     oms_status_enu_t instantiate();
diff --git a/src/OMSimulatorLib/Model.cpp b/src/OMSimulatorLib/Model.cpp
@@ -187,6 +187,23 @@ oms_status_enu_t oms::Model::loadSnapshot(const pugi::xml_node& node)
   return oms_status_ok;
 }
 
+oms_status_enu_t oms::Model::duplicateVariant(const ComRef& crefA, const ComRef& crefB)
+{
+  if (!crefA.isEmpty())
+    return logError("only top level model is allowed");
+
+  // copy the current snapshot
+  char* fullsnapshot = NULL;
+  exportSnapshot("", &fullsnapshot);
+
+  listVariants.push_back(fullsnapshot);
+
+  // set the current variantName
+  this->variantName = std::string(crefB) + ".ssd";
+  this->signalFilterFilename = "resources/signalFilter_" + std::string(crefB) + ".xml";
+  return oms_status_ok;
+}
+
 oms_status_enu_t oms::Model::importSnapshot(const char* snapshot_, char** newCref)
 {
   if (!validState(oms_modelState_virgin))
@@ -343,7 +360,7 @@ oms_status_enu_t oms::Model::list(const oms::ComRef& cref, char** contents)
       pugi::xml_node ssdNode = snapshot.getTemplateResourceNodeSSD("SystemStructure.ssd", this->getCref());
       pugi::xml_node system_node = ssdNode.append_child(oms::ssp::Draft20180219::ssd::system);
 
-      subsystem->exportToSSD(system_node, snapshot);
+      subsystem->exportToSSD(system_node, snapshot, this->variantName);
       doc.append_copy(snapshot.getResourceNode("SystemStructure.ssd").first_child());
     }
     else
@@ -356,7 +373,7 @@ oms_status_enu_t oms::Model::list(const oms::ComRef& cref, char** contents)
       pugi::xml_node ssdNode = snapshot.getTemplateResourceNodeSSD("SystemStructure.ssd", this->getCref());
       pugi::xml_node system_node = ssdNode.append_child(oms::ssp::Draft20180219::ssd::system);
 
-      component->exportToSSD(system_node, snapshot);
+      component->exportToSSD(system_node, snapshot, this->variantName);
       doc.append_copy(snapshot.getResourceNode("SystemStructure.ssd").first_child());
     }
   }
@@ -703,12 +720,12 @@ oms_status_enu_t oms::Model::addSystem(const oms::ComRef& cref, oms_system_enu_t
 
 oms_status_enu_t oms::Model::exportToSSD(Snapshot& snapshot) const
 {
-  pugi::xml_node ssdNode = snapshot.getTemplateResourceNodeSSD("SystemStructure.ssd", this->getCref());
+  pugi::xml_node ssdNode = snapshot.getTemplateResourceNodeSSD(this->variantName, this->getCref());
 
   if (system)
   {
     pugi::xml_node system_node = ssdNode.append_child(oms::ssp::Draft20180219::ssd::system);
-    if (oms_status_ok != system->exportToSSD(system_node, snapshot))
+    if (oms_status_ok != system->exportToSSD(system_node, snapshot, this->variantName))
       return logError("export of system failed");
   }
 
@@ -958,6 +975,27 @@ void oms::Model::writeAllResourcesToFilesystem(std::vector<std::string>& resourc
       logError("failed to export \"" + filename + " to directory " + tempDir);
   }
 
+  // get all the variants and its resources
+  // TODO how to handle mutiple resouces with same file name (e.g) resources/signalFilter.xml and other ssv resouces
+  for (auto const & variant : listVariants)
+  {
+    std::vector<std::string> variantResources;
+    Snapshot snapshot_;
+    snapshot_.import(variant);
+    snapshot_.getResources(variantResources);
+    //snapshot_.debugPrintAll();
+    for (auto const &variantfilename : variantResources)
+    {
+      //std::cout << "\n variant resources : " << variantfilename;
+      auto file = std::find(resources.begin(), resources.end(), variantfilename);
+      if (file == resources.end())
+      {
+        resources.push_back(variantfilename);
+        snapshot_.writeResourceNode(variantfilename, filesystem::path(tempDir));
+      }
+    }
+  }
+
   // export the unreferenced ssv and ssm files to ssp, this must be extended to export all unreferenced resources
   for (auto & it : importedResources)
   {
diff --git a/src/OMSimulatorLib/Model.h b/src/OMSimulatorLib/Model.h
@@ -78,6 +78,7 @@ namespace oms
     oms_status_enu_t addResources(const ComRef& cref, const std::string& path);
     oms_status_enu_t deleteReferencesInSSD(const ComRef& cref);
     oms_status_enu_t deleteResourcesInSSP(const std::string& filename);
+    oms_status_enu_t duplicateVariant(const ComRef& crefA, const ComRef& crefB);
     oms_status_enu_t referenceResources(const ComRef& cref, const std::string& ssmFile);
     oms_status_enu_t reduceSSV(const std::string& ssvfile, const std::string& ssmfile, const std::string& filepath);
     oms_status_enu_t exportToSSD(Snapshot& snapshot) const;
@@ -135,6 +136,10 @@ namespace oms
 
     std::vector<std::string> importedResources;  ///< list of imported resources from ssp
 
+    std::vector<char*> listVariants;  ///< list of all variants copied when user create a new variant using oms_duplicateVariant()
+
+    std::string getVariantName() {return variantName;}
+
   private: // methods
     Model(const ComRef& cref, const std::string& tempDir);
 
@@ -169,6 +174,8 @@ namespace oms
     std::string resultFilename; ///< default <name>_res.mat
     std::string signalFilterFilename = "resources/signalFilter.xml";
 
+    std::string variantName = "SystemStructure.ssd";  ///< default name
+
     std::vector<std::string> externalResources;  ///< list of external ssv or ssm resources from filesystem
 
     bool isolatedFMU = false;
diff --git a/src/OMSimulatorLib/OMSimulator.cpp b/src/OMSimulatorLib/OMSimulator.cpp
@@ -916,6 +916,19 @@ oms_status_enu_t oms_addSubModel(const char* cref, const char* fmuPath)
   return system->addSubModel(tail, fmuPath);
 }
 
+oms_status_enu_t oms_duplicateVariant(const char* crefA, const char* crefB)
+{
+  oms::ComRef tail(crefA);
+  oms::ComRef front = tail.pop_front();
+
+  oms::Model* model = oms::Scope::GetInstance().getModel(front);
+  if (!model)
+    return logError_ModelNotInScope(front);
+
+  return model->duplicateVariant(tail, crefB);
+
+}
+
 oms_status_enu_t oms_replaceSubModel(const char* cref, const char* fmuPath, bool dryRun, int* warningCount)
 {
   oms::ComRef tail(cref);
diff --git a/src/OMSimulatorLib/OMSimulator.h b/src/OMSimulatorLib/OMSimulator.h
@@ -82,6 +82,7 @@ OMSAPI oms_status_enu_t OMSCALL oms_deleteConnectorFromBus(const char* busCref,
 OMSAPI oms_status_enu_t OMSCALL oms_deleteConnectorFromTLMBus(const char* busCref, const char* connectorCref);
 OMSAPI oms_status_enu_t OMSCALL oms_deleteResources(const char* cref);
 OMSAPI oms_status_enu_t OMSCALL oms_doStep(const char* cref);
+OMSAPI oms_status_enu_t OMSCALL oms_duplicateVariant(const char* crefA, const char* crefB);
 OMSAPI oms_status_enu_t OMSCALL oms_export(const char* cref, const char* filename);
 OMSAPI oms_status_enu_t OMSCALL oms_exportDependencyGraphs(const char* cref, const char* initialization, const char* event, const char* simulation);
 OMSAPI oms_status_enu_t OMSCALL oms_exportSnapshot(const char* cref, char** contents);
diff --git a/src/OMSimulatorLib/System.cpp b/src/OMSimulatorLib/System.cpp
@@ -660,7 +660,7 @@ oms_status_enu_t oms::System::listUnconnectedConnectors(char** contents) const
   return oms_status_ok;
 }
 
-oms_status_enu_t oms::System::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const
+oms_status_enu_t oms::System::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const
 {
   node.append_attribute("name") = this->getCref().c_str();
 
@@ -678,21 +678,28 @@ oms_status_enu_t oms::System::exportToSSD(pugi::xml_node& node, Snapshot& snapsh
     }
   }
 
-  values.exportParameterBindings(node, snapshot);
+  // // get variant name
+  // std::string variantName = "";
+  // if (parentModel)
+  //   variantName = parentModel->getVariantName();
+  // else
+  //   variantName = parentSystem->parentModel->getVariantName();
+
+  values.exportParameterBindings(node, snapshot, variantName);
 
   if (subelements.size() > 1)
   {
     pugi::xml_node elements_node = node.append_child(oms::ssp::Draft20180219::ssd::elements);
     for (const auto& subsystem : subsystems)
     {
       pugi::xml_node system_node = elements_node.append_child(oms::ssp::Draft20180219::ssd::system);
-      if (oms_status_ok != subsystem.second->exportToSSD(system_node, snapshot))
+      if (oms_status_ok != subsystem.second->exportToSSD(system_node, snapshot, variantName))
         return logError("export of system failed");
     }
     for (const auto& component : components)
     {
       pugi::xml_node component_node = elements_node.append_child(oms::ssp::Draft20180219::ssd::component);
-      if (oms_status_ok != component.second->exportToSSD(component_node, snapshot))
+      if (oms_status_ok != component.second->exportToSSD(component_node, snapshot, variantName))
         return logError("export of component failed");
     }
   }
diff --git a/src/OMSimulatorLib/System.h b/src/OMSimulatorLib/System.h
@@ -98,7 +98,7 @@ namespace oms
     oms_status_enu_t replaceSubModel(const ComRef& cref, const std::string& fmuPath, bool dryRun, int& warningCount);
     bool isValidScalarVariable(Component* referenceComponent, Component* replacingComponent, Connection* connection, const ComRef& crefA, const ComRef& crefB, const ComRef& signalName, const std::string& path, std::vector<std::string>& warningList);
     bool validCref(const ComRef& cref);
-    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const;
+    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const;
     oms_status_enu_t exportToSSV(Snapshot& snapshot) const;
     oms_status_enu_t importFromSnapshot(const pugi::xml_node& node, const std::string& sspVersion, const Snapshot& snapshot);
     void setGeometry(const ssd::ElementGeometry& geometry) {element.setGeometry(&geometry);}
diff --git a/src/OMSimulatorLib/TLM/ExternalModel.cpp b/src/OMSimulatorLib/TLM/ExternalModel.cpp
@@ -87,7 +87,7 @@ oms_status_enu_t oms::ExternalModel::getRealParameter(const std::string& var, do
   return oms_status_error;
 }
 
-oms_status_enu_t oms::ExternalModel::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const
+oms_status_enu_t oms::ExternalModel::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const
 {
   pugi::xml_node annotations_node = node.append_child(oms::ssp::Draft20180219::ssd::annotations);
   pugi::xml_node annotation_node = annotations_node.append_child(oms::ssp::Version1_0::ssc::annotation);
diff --git a/src/OMSimulatorLib/TLM/ExternalModel.h b/src/OMSimulatorLib/TLM/ExternalModel.h
@@ -60,7 +60,7 @@ namespace oms
     const std::string getStartScript() const {return externalModelInfo.getStartScript();}
     const std::map<std::string, oms::Option<double>>& getRealParameters() const {return realParameters;}
 
-    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const;
+    oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const;
     oms_status_enu_t instantiate();
     oms_status_enu_t initialize();
     oms_status_enu_t terminate();
diff --git a/src/OMSimulatorLib/Values.cpp b/src/OMSimulatorLib/Values.cpp
@@ -1068,7 +1068,7 @@ oms_status_enu_t oms::Values::exportStartValuesHelper(pugi::xml_node& node) cons
   return oms_status_ok;
 }
 
-void oms::Values::exportParameterBindings(pugi::xml_node &node, Snapshot &snapshot) const
+void oms::Values::exportParameterBindings(pugi::xml_node &node, Snapshot &snapshot, std::string variantName) const
 {
   if (!parameterResources.empty())
   {
@@ -1101,26 +1101,48 @@ void oms::Values::exportParameterBindings(pugi::xml_node &node, Snapshot &snapsh
           else
           {
             // export to ssv file
+
+            // check for variants and create a new file name for variants to have their own resources
+            filesystem::path ssvFilePath;
+            if (variantName != "SystemStructure.ssd")
+            {
+              filesystem::path p = res.first;
+              ssvFilePath = "resources/" + std::string(ComRef(variantName).pop_front()) + "_" + p.filename().generic_string();
+            }
+            else
+              ssvFilePath = res.first;
+
             pugi::xml_node node_parameter_binding;
             if (res.second.linkResources)
             {
               node_parameter_binding = node_parameters_bindings.append_child(oms::ssp::Version1_0::ssd::parameter_binding);
-              node_parameter_binding.append_attribute("source") = res.first.c_str();
+              node_parameter_binding.append_attribute("source") = ssvFilePath.generic_string().c_str();
             }
             //std::cout << "\n export To SSV file :" << res.first.c_str() << "=" << res.second.ssmFile;
-            pugi::xml_node ssvNode = snapshot.getTemplateResourceNodeSSV(res.first, "parameters");
+
+            pugi::xml_node ssvNode = snapshot.getTemplateResourceNodeSSV(ssvFilePath, "parameters");
             res.second.exportToSSV(ssvNode);
-            res.second.exportUnitDefinitions(snapshot, res.first);
+            res.second.exportUnitDefinitions(snapshot, ssvFilePath.generic_string());
 
             // export SSM file if exist
             if (!res.second.ssmFile.empty())
             {
+              // check for variants and create a new file name for variants to have their own resources
+              filesystem::path ssmFilePath;
+              if (variantName != "SystemStructure.ssd")
+              {
+                filesystem::path p = res.second.ssmFile;
+                ssmFilePath = "resources/" + std::string(ComRef(variantName).pop_front()) + "_" + p.filename().generic_string();
+              }
+              else
+                ssmFilePath = res.second.ssmFile;
+
               if (res.second.linkResources)
               {
                 pugi::xml_node ssd_parameter_mapping = node_parameter_binding.append_child(oms::ssp::Version1_0::ssd::parameter_mapping);
-                ssd_parameter_mapping.append_attribute("source") = res.second.ssmFile.c_str();
+                ssd_parameter_mapping.append_attribute("source") = ssmFilePath.generic_string().c_str();
               }
-              pugi::xml_node ssmNode = snapshot.getTemplateResourceNodeSSM(res.second.ssmFile);
+              pugi::xml_node ssmNode = snapshot.getTemplateResourceNodeSSM(ssmFilePath);
               res.second.exportParameterMappingToSSM(ssmNode);
             }
           }
diff --git a/src/OMSimulatorLib/Values.h b/src/OMSimulatorLib/Values.h
@@ -112,7 +112,7 @@ namespace oms
     oms_status_enu_t rename(const oms::ComRef& oldCref, const oms::ComRef& newCref);
     oms_status_enu_t renameInResources(const oms::ComRef& oldCref, const oms::ComRef& newCref);
 
-    void exportParameterBindings(pugi::xml_node& node, Snapshot& snapshot) const;
+    void exportParameterBindings(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const;
 
     bool hasResources(); ///< returns if the system or subsystem or submodule have parameter resources either as ssv or inline
 
diff --git a/src/OMSimulatorLua/OMSimulatorLua.c b/src/OMSimulatorLua/OMSimulatorLua.c
diff --git a/testsuite/simulation/Makefile b/testsuite/simulation/Makefile
diff --git a/testsuite/simulation/duplicateVariant1.lua b/testsuite/simulation/duplicateVariant1.lua
diff --git a/testsuite/simulation/duplicateVariant2.lua b/testsuite/simulation/duplicateVariant2.lua
diff --git a/testsuite/simulation/duplicateVariant3.lua b/testsuite/simulation/duplicateVariant3.lua

Original file line number	Diff line number	Diff line change
`@@ -366,7 +366,7 @@ oms::Component* oms::ComponentFMUCS::NewComponent(const pugi::xml_node& node, om`
`366`	`366`	`return component;`
`367`	`367`	`}`
`368`	`368`
`369`		`-oms_status_enu_t oms::ComponentFMUCS::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const`
	`369`	`+oms_status_enu_t oms::ComponentFMUCS::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const`
`370`	`370`	`{`
`371`	`371`	`#if !defined(NO_TLM)`
`372`	`372`	`if (tlmbusconnectors[0])`
`@@ -394,7 +394,7 @@ oms_status_enu_t oms::ComponentFMUCS::exportToSSD(pugi::xml_node& node, Snapshot`
`394`	`394`	`return oms_status_error;`
`395`	`395`
`396`	`396`	`// export ParameterBindings at component level`
`397`		`- values.exportParameterBindings(node, snapshot);`
	`397`	`+ values.exportParameterBindings(node, snapshot, variantName);`
`398`	`398`
`399`	`399`	`return oms_status_ok;`
`400`	`400`	`}`
Original file line number	Diff line number	Diff line change
`@@ -367,7 +367,7 @@ oms::Component* oms::ComponentFMUME::NewComponent(const pugi::xml_node& node, om`
`367`	`367`	`return component;`
`368`	`368`	`}`
`369`	`369`
`370`		`-oms_status_enu_t oms::ComponentFMUME::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const`
	`370`	`+oms_status_enu_t oms::ComponentFMUME::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const`
`371`	`371`	`{`
`372`	`372`	`#if !defined(NO_TLM)`
`373`	`373`	`if (tlmbusconnectors[0])`
`@@ -395,7 +395,7 @@ oms_status_enu_t oms::ComponentFMUME::exportToSSD(pugi::xml_node& node, Snapshot`
`395`	`395`	`return oms_status_error;`
`396`	`396`
`397`	`397`	`// export ParameterBindings at component level`
`398`		`- values.exportParameterBindings(node, snapshot);`
	`398`	`+ values.exportParameterBindings(node, snapshot, variantName);`
`399`	`399`
`400`	`400`	`return oms_status_ok;`
`401`	`401`	`}`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ oms::Component* oms::ComponentTable::NewComponent(const pugi::xml_node& node, om`
`161`	`161`	`return component;`
`162`	`162`	`}`
`163`	`163`
`164`		`-oms_status_enu_t oms::ComponentTable::exportToSSD(pugi::xml_node& node, Snapshot& snapshot) const`
	`164`	`+oms_status_enu_t oms::ComponentTable::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const`
`165`	`165`	`{`
`166`	`166`	`node.append_attribute("name") = this->getCref().c_str();`
`167`	`167`	`node.append_attribute("type") = "application/table";`