Changeset 134:4bc25c8cea06 in finroc_plugins_runtime_construction

Timestamp:

27.04.2020 05:59:58 (4 years ago)

Author:

Max Reichardt <mreichardt@…>

Branch:

17.03

Children:

135:c8f6a95b501e, 136:f79534c8ea55

Phase:

public

Message:

Adds 'include' mechanism to structure xml files. Tracks info on origins of created elements for this purpose (implementation allows to cleanly remove includes at runtime - and always preserves order of elements).

Files:

• tEditableInterfaces.cpp (modified) (2 diffs)
• tEditableInterfaces.h (modified) (2 diffs)
• tFinstructable.cpp (modified) (17 diffs)
• tFinstructable.h (modified) (4 diffs)
• tOriginData.h (added)
• tPortCreationList.cpp (modified) (17 diffs)
• tPortCreationList.h (modified) (6 diffs)

tEditableInterfaces.cpp

@@ -114 +114 @@
 }
 
-core::tPortGroup& tEditableInterfaces::LoadInterfacePorts(const rrlib::xml::tNode& node)
+core::tPortGroup& tEditableInterfaces::LoadInterfacePorts(const rrlib::xml::tNode& node, bool mark_created_ports_finstructed, const tOrigin* origin)
 {
   std::string name = node.GetStringAttribute("name");
@@ -121 +121 @@
     if (name == interface.first->GetName())
     {
-      tPortCreationList port_creation_list(*interface.first, interface.first->GetDefaultPortFlags(), interface.second);
+      tPortCreationList port_creation_list(*interface.first, interface.first->GetDefaultPortFlags(), interface.second, mark_created_ports_finstructed, origin);
       node >> port_creation_list;
       return *interface.first;

tEditableInterfaces.h

@@ -86 +86 @@
 public:
 
+  typedef tPortCreationList::tOrigin tOrigin;
+
   /*! Listener notified whenever editable interfaces are changed */
   class tListener
@@ -115 +117 @@
    *
    * \param node XML node to load ports from
+   * \param mark_created_ports_finstructed Whether to flag created ports as 'finstructed'. Only such ports are saved to XML file - and show up in interface editing dialog in finstruct.
+   * \param origin Origin for which to create and manage ports (all ports that do no match origin are not touched)
    * \return Interface whose ports were updated
    *
    * \throw Throws different kinds of std::exceptions if loading fails
    */
-  core::tPortGroup& LoadInterfacePorts(const rrlib::xml::tNode& node);
+  core::tPortGroup& LoadInterfacePorts(const rrlib::xml::tNode& node, bool mark_created_ports_finstructed = true, const tOrigin* origin = nullptr);
 
   /*!

tFinstructable.cpp

@@ -45 +45 @@
 #include "plugins/runtime_construction/tEditableInterfaces.h"
 #include "plugins/runtime_construction/dynamic_loading.h"
+#include "plugins/runtime_construction/tConstructorCreateModuleAction.h"
 
 //----------------------------------------------------------------------
@@ -73 +74 @@
 //----------------------------------------------------------------------
 
+namespace
+{
+
+/*! We do not want to have this prefix in XML file names, as this will not be found when a system installation is used */
+const char* cUNWANTED_XML_FILE_PREFIX = "sources/cpp/";
+
+/*! Characters that are not escaped in path URIs */
+const char* cUNENCODED_RESERVED_CHARACTERS_PATH = "!$&'()*+,;= @";
+
+/*! Current version of file format (YYMM) */
+const uint cVERSION = 1703;
+
 //----------------------------------------------------------------------
 // Implementation
@@ -78 +91 @@
 
 /*! Thread currently saving finstructable group */
-static rrlib::thread::tThread* saving_thread = nullptr;
+rrlib::thread::tThread* saving_thread = nullptr;
 
 /*! Temporary variable for saving: .so files that should be loaded prior to instantiating this group */
-static std::set<tSharedLibrary> dependencies_tmp;
+std::set<tSharedLibrary> dependencies_tmp;
 
 /*! Loaded finroc libraries at startup */
-static std::set<tSharedLibrary> startup_loaded_finroc_libs;
-
-/*! We do not want to have this prefix in XML file names, as this will not be found when a system installation is used */
-static const char* cUNWANTED_XML_FILE_PREFIX = "sources/cpp/";
-
-/*! Characters that are not escaped in path URIs */
-static const char* cUNENCODED_RESERVED_CHARACTERS_PATH = "!$&'()*+,;= @";
-
-/*! Current version of file format (YYMM) */
-static const uint cVERSION = 1703;
-
-static rrlib::uri::tPath ReplaceInterfaceInPath(const rrlib::uri::tPath& path, const std::string& new_interface)
+std::set<tSharedLibrary> startup_loaded_finroc_libs;
+
+
+rrlib::uri::tPath ReplaceInterfaceInPath(const rrlib::uri::tPath& path, const std::string& new_interface)
 {
   if (path.Size() < 2)
@@ -109 +114 @@
   return rrlib::uri::tPath(path.IsAbsolute(), path_components.begin(), path_components.end());
 }
+
+/*! Specialized tFinstructable class to realize include mechanism */
+class tIncludeFinstructable : public tFinstructable
+{
+public:
+  /*!
+   * Root framework element that this annotation belongs to
+   * Optional setting that overrides element that annotation is attached to
+   */
+  core::tFrameworkElement* root_framework_element = nullptr;
+  std::string xml_file;
+  core::tFrameworkElement* origin = nullptr;
+
+  tIncludeFinstructable() : tFinstructable(xml_file)
+  {}
+};
+
+// Returns tIncludeFinstructable if 'finstructable' is one - otherwise nullptr
+tIncludeFinstructable* IncludeFinstructable(tFinstructable* finstructable)
+{
+  return typeid(*finstructable) == typeid(tIncludeFinstructable) ? static_cast<tIncludeFinstructable*>(finstructable) : nullptr;
+}
+const tIncludeFinstructable* IncludeFinstructable(const tFinstructable* finstructable)
+{
+  return typeid(*finstructable) == typeid(tIncludeFinstructable) ? static_cast<const tIncludeFinstructable*>(finstructable) : nullptr;
+}
+
+
+/*! Framework element with create action for inclusion of finstructable XML files */
+class tIncludeElement : public core::tFrameworkElement
+{
+public:
+  tIncludeElement(core::tFrameworkElement* parent, const std::string& name, const std::string& xml_file) :
+    tFrameworkElement(GetIncludesParent(parent, true), xml_file),
+    xml_file(xml_file)
+  {
+    tFinstructable::Include(*parent, xml_file, this);
+  }
+
+  std::string xml_file;
+
+  void OnManagedDelete() override
+  {
+    // Remove the whole included structure
+    auto parent = GetParent();
+    parent = parent ? parent->GetParent() : parent;
+    if (parent && parent->IsReady())
+    {
+      for (auto it = parent->SubElementsBegin(); it != parent->SubElementsEnd(); ++it)
+      {
+        tOriginDataAnnotation* annotation = it->GetAnnotation<tOriginDataAnnotation>();
+        if (annotation && annotation->Data().origin == this)
+        {
+          it->ManagedDelete();
+        }
+      }
+    }
+  }
+
+  static core::tFrameworkElement* GetIncludesParent(core::tFrameworkElement* parent, bool create_if_it_does_not_exist)
+  {
+    auto result = parent->GetChild("Includes");
+    if ((!result) && create_if_it_does_not_exist)
+    {
+      result = new core::tFrameworkElement(parent, "Includes");
+      result->Init();
+    }
+    return result;
+  }
+};
+
+tConstructorCreateModuleAction<tIncludeElement, std::string> cINCLUDE_CREATE_ACTION("Include", "File");
+
+
+bool HasNonDefaultFinstructInfo(const parameters::internal::tParameterInfo& info)
+{
+  for (auto & setting : info.Settings())
+  {
+    if (setting.high_precedence && setting.origin == nullptr)
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
+}
+
 
 tFinstructable::tFinstructable(const std::string& xml_file) :
@@ -168 +261 @@
 }
 
+core::tFrameworkElement* tFinstructable::GetFrameworkElement() const
+{
+  auto include_instance = IncludeFinstructable(this);
+  return include_instance ? include_instance->root_framework_element : this->GetAnnotated<core::tFrameworkElement>();
+}
+
 std::string tFinstructable::GetLogDescription() const
 {
@@ -187 +286 @@
   }
   return s;
+}
+
+void tFinstructable::Include(core::tFrameworkElement& parent, const std::string& xml_file, core::tFrameworkElement* origin)
+{
+  tIncludeFinstructable temp_finstructable;
+  temp_finstructable.xml_file = xml_file;
+  temp_finstructable.root_framework_element = &parent;
+  temp_finstructable.origin = origin;
+  temp_finstructable.LoadXml();
 }
 
@@ -227 +335 @@
     }
     created = action.CreateModule(parent, name, spl);
-    SetFinstructed(*created, action, spl);
+    tOriginData data;
+    auto include_instance = IncludeFinstructable(this);
+    if (include_instance && include_instance->origin)
+    {
+      data.origin = include_instance->origin;
+      SetFinstructed(*created, action, spl, data);
+    }
+    else if (!include_instance)
+    {
+      SetFinstructed(*created, action, spl, data);
+    }
     if (parameters)
     {
@@ -273 +391 @@
   else
   {
+    auto include_instance = IncludeFinstructable(this);
+    bool high_precendence = include_instance == nullptr;
+    auto origin = include_instance ? include_instance->origin : nullptr;
     if (outermost_group && node.HasAttribute("cmdline") && (!IsResponsibleForConfigFileConnections(parameter_port)))
     {
-      pi->SetCommandLineOption(node.GetStringAttribute("cmdline"));
+      pi->SetCommandLineOption(node.GetStringAttribute("cmdline"), high_precendence, origin);
     }
     else
     {
-      pi->Deserialize(node, true, outermost_group);
+      pi->Deserialize(node, high_precendence, outermost_group, origin);
     }
     try
@@ -295 +416 @@
 {
   {
+    auto include_instance = IncludeFinstructable(this);
+    tOriginData origin_data;
+    if (include_instance && include_instance->origin)
+    {
+      origin_data.origin = include_instance->origin;
+    }
+
     rrlib::thread::tLock lock2(core::tRuntimeEnvironment::GetInstance().GetStructureMutex());
     try
@@ -359 +487 @@
           Instantiate(*node, GetFrameworkElement());
         }
+        if (name == "include")
+        {
+          std::string file;
+          try
+          {
+            file = node->GetStringAttribute("file");
+            auto created = new tIncludeElement(this->GetFrameworkElement(), file, file);
+            origin_data.order = std::chrono::steady_clock::now().time_since_epoch().count();
+            if (!include_instance)
+            {
+              created->SetFlag(tFlag::FINSTRUCTED);
+            }
+            created->EmplaceAnnotation<tOriginDataAnnotation>(origin_data);
+            created->Init();
+          }
+          catch (const std::exception& e)
+          {
+            FINROC_LOG_PRINT(ERROR, "Including ", file, " failed: ", e);
+          }
+        }
       }
 
@@ -373 +521 @@
             try
             {
-              core::tPortGroup& loaded_interface = editable_interfaces->LoadInterfacePorts(*node);
+              auto include_instance = IncludeFinstructable(this);
+              core::tPortGroup& loaded_interface = editable_interfaces->LoadInterfacePorts(*node, !include_instance, include_instance ? include_instance->origin : nullptr);
 
               // Move RPC port to suitable interfaces when loading legacy files
@@ -418 +567 @@
           }
         }
-        else if (name == "element")
+        else if (name == "element" || name == "include")
         {
           // already instantiated
@@ -443 +592 @@
               destination_uri_parsed.path = rrlib::uri::tPath(destination_string);
             }
-            core::tUriConnectOptions connect_options(core::tConnectionFlag::FINSTRUCTED);
+            core::tUriConnectOptions connect_options;
+            connect_options.flags.Set(core::tConnectionFlag::FINSTRUCTED, !static_cast<bool>(include_instance));  // TODO attach origin data to connectors also
             if (node->HasAttribute("flags"))
             {
@@ -713 +863 @@
     bool is_responsible_for_parameter_links = IsResponsibleForConfigFileConnections(*port);
 
-    if (info && info->HasNonDefaultFinstructInfo() && (is_responsible_for_parameter_links || (outermost_group && info->GetCommandLineOption().length())))
+    if (info && HasNonDefaultFinstructInfo(*info) && (is_responsible_for_parameter_links || (outermost_group && info->GetCommandLineOption().length())))
     {
       // Save Parameter
@@ -725 +875 @@
       else
       {
-        info->Serialize(parameter_node, true, outermost_group);
+        info->Serialize(parameter_node, true, outermost_group, nullptr);
       }
       result = true;
@@ -1057 +1207 @@
 void tFinstructable::SerializeChildren(rrlib::xml::tNode& node, tFrameworkElement& current)
 {
-  for (auto child = current.ChildrenBegin(); child != current.ChildrenEnd(); ++child)
-  {
+  std::vector<std::pair<tOriginData, core::tFrameworkElement*>> children_to_serialize;
+  std::vector<core::tFrameworkElement*> elements_to_scan = { &current };
+  auto include_parent = tIncludeElement::GetIncludesParent(&current, false);
+  if (include_parent)
+  {
+    elements_to_scan.push_back(include_parent);
+  }
+  for (auto element_to_scan : elements_to_scan)
+  {
+    for (auto child = element_to_scan->ChildrenBegin(); child != element_to_scan->ChildrenEnd(); ++child)
+    {
+      auto origin_data = child->GetAnnotation<tOriginDataAnnotation>();
+      if (child->IsReady() && child->GetFlag(tFlag::FINSTRUCTED) && origin_data && (child->GetAnnotation<parameters::internal::tStaticParameterList>() || typeid(*child) == typeid(tIncludeElement)))
+      {
+        children_to_serialize.emplace_back(origin_data->Data(), &*child);
+      }
+    }
+  }
+
+  std::sort(children_to_serialize.begin(), children_to_serialize.end());
+
+  for (auto & child_entry : children_to_serialize)
+  {
+    auto child = child_entry.second;
+
+    if (typeid(*child) == typeid(tIncludeElement))
+    {
+      rrlib::xml::tNode& n = node.AddChildNode("include");
+      n.SetAttribute("file", static_cast<tIncludeElement*>(child)->xml_file);
+      continue;
+    }
+
     parameters::internal::tStaticParameterList* spl = child->GetAnnotation<parameters::internal::tStaticParameterList>();
     tConstructorParameters* cps = child->GetAnnotation<tConstructorParameters>();
-    if (child->IsReady() && child->GetFlag(tFlag::FINSTRUCTED))
-    {
-      // serialize framework element
-      rrlib::xml::tNode& n = node.AddChildNode("element");
-      n.SetAttribute("name", child->GetName());
-      tCreateFrameworkElementAction* cma = tCreateFrameworkElementAction::GetConstructibleElements()[spl->GetCreateAction()];
-      n.SetAttribute("group", cma->GetModuleGroup().ToString());
-      //if (boost::ends_with(cma->GetModuleGroup(), ".so"))
-      //{
-      AddDependency(cma->GetModuleGroup());
-      //}
-      n.SetAttribute("type", cma->GetName());
-      if (cps != nullptr)
-      {
-        rrlib::xml::tNode& pn = n.AddChildNode("constructor");
-        cps->Serialize(pn, true);
-      }
-      if (spl != nullptr)
-      {
-        rrlib::xml::tNode& pn = n.AddChildNode("parameters");
-        spl->Serialize(pn, true);
-      }
-
-      // serialize its children
-      if (!child->GetFlag(tFlag::FINSTRUCTABLE_GROUP))
-      {
-        SerializeChildren(n, *child);
-      }
-    }
-  }
-}
-
-void tFinstructable::SetFinstructed(tFrameworkElement& fe, tCreateFrameworkElementAction& create_action, tConstructorParameters* params)
+
+    // serialize framework element
+    rrlib::xml::tNode& n = node.AddChildNode("element");
+    n.SetAttribute("name", child->GetName());
+    assert(spl);
+    tCreateFrameworkElementAction* cma = tCreateFrameworkElementAction::GetConstructibleElements()[spl->GetCreateAction()];
+    n.SetAttribute("group", cma->GetModuleGroup().ToString());
+    //if (boost::ends_with(cma->GetModuleGroup(), ".so"))
+    //{
+    AddDependency(cma->GetModuleGroup());
+    //}
+    n.SetAttribute("type", cma->GetName());
+    if (cps)
+    {
+      rrlib::xml::tNode& pn = n.AddChildNode("constructor");
+      cps->Serialize(pn, true);
+    }
+    if (spl)
+    {
+      rrlib::xml::tNode& pn = n.AddChildNode("parameters");
+      spl->Serialize(pn, true);
+    }
+
+    // serialize its children
+    if (!child->GetFlag(tFlag::FINSTRUCTABLE_GROUP))
+    {
+      SerializeChildren(n, *child);
+    }
+  }
+}
+
+void tFinstructable::SetFinstructed(tFrameworkElement& fe, tCreateFrameworkElementAction& create_action, tConstructorParameters* params, tOriginData origin_data)
 {
   assert(!fe.GetFlag(tFlag::FINSTRUCTED) && (!fe.IsReady()));
@@ -1106 +1285 @@
     }
   }
-  fe.SetFlag(tFlag::FINSTRUCTED);
+  bool include_finstructed = origin_data.origin;
+  fe.SetFlag(tFlag::FINSTRUCTED, (!include_finstructed));
   if (params)
   {
     fe.AddAnnotation<tConstructorParameters>(*params);
   }
+
+  origin_data.order = std::chrono::steady_clock::now().time_since_epoch().count();
+  fe.EmplaceAnnotation<tOriginDataAnnotation>(origin_data);
 }
 

tFinstructable.h

@@ -54 +54 @@
 //----------------------------------------------------------------------
 #include "plugins/runtime_construction/tCreateFrameworkElementAction.h"
+#include "plugins/runtime_construction/tOriginData.h"
 
 //----------------------------------------------------------------------
@@ -116 +117 @@
 
   /*!
+   * "Includes" finstructable XML file: Adds all structure defined in XML file to specified parent element.
+   * Note that the created structure is not marked 'finstructed' (so that saving the main file does not suddenly include all of it).
+   *
+   * \param parent Framework element to add structure to
+   * \param xml_file Finstructable XML file containing structure to add
+   * \param origin Origin (optional). If set, adds tOriginDataAnnotation with this origin to created elements.
+   */
+  static void Include(core::tFrameworkElement& parent, const std::string& xml_file, core::tFrameworkElement* origin = nullptr);
+
+  /*!
    * Loads and instantiates contents of xml file
    *
@@ -145 +156 @@
    * \param create_action Action with which framework element was created
    * \param params Parameters that module was created with (may be null)
-   */
-  static void SetFinstructed(core::tFrameworkElement& fe, tCreateFrameworkElementAction& create_action, tConstructorParameters* params);
+   * \param origin_data Origin data to attach (if not set, order will be set to steady_clock time)
+   */
+  static void SetFinstructed(core::tFrameworkElement& fe, tCreateFrameworkElementAction& create_action, tConstructorParameters* params, tOriginData origin_data = tOriginData());
 
   /*!
@@ -202 +214 @@
    * \return Root framework element that this annotation belongs to
    */
-  core::tFrameworkElement* GetFrameworkElement() const
-  {
-    return this->GetAnnotated<core::tFrameworkElement>();
-  }
+  core::tFrameworkElement* GetFrameworkElement() const;
 
   /*!

tPortCreationList.cpp

@@ -108 +108 @@
   selectable_create_options(),
   list(),
-  io_vector(NULL),
+  io_vector(nullptr),
   flags(tFlags()),
-  ports_flagged_finstructed(true)
+  ports_flagged_finstructed(true),
+  origin(nullptr)
 {}
 
-tPortCreationList::tPortCreationList(core::tFrameworkElement& port_group, tFlags flags, const tPortCreateOptions& selectable_create_options, bool ports_flagged_finstructed) :
+tPortCreationList::tPortCreationList(core::tFrameworkElement& port_group, tFlags flags, const tPortCreateOptions& selectable_create_options, bool ports_flagged_finstructed, const tOrigin* origin) :
   selectable_create_options(),
   list(),
   io_vector(&port_group),
   flags(flags | (ports_flagged_finstructed ? tFlag::FINSTRUCTED : tFlag::PORT)),
-  ports_flagged_finstructed(ports_flagged_finstructed)
+  ports_flagged_finstructed(ports_flagged_finstructed),
+  origin(origin)
 {
   if (!flags.Get(tFlag::SHARED) && selectable_create_options.Get(tPortCreateOption::SHARED))
@@ -133 +135 @@
 {
   rrlib::thread::tLock lock(io_vector->GetStructureMutex());
-  CheckPort(NULL, *io_vector, flags, name, dt, create_options, NULL);
+  CheckPort(nullptr, *io_vector, flags, name, dt, create_options, nullptr, this->GetSize());
 }
 
@@ -139 +141 @@
 {
   rrlib::thread::tLock lock(io_vector->GetStructureMutex());
-  std::vector<core::tAbstractPort*> ports1;
-  GetPorts(*this->io_vector, ports1, ports_flagged_finstructed);
-  std::vector<core::tAbstractPort*> ports2;
-  GetPorts(io_vector_, ports2, ports_flagged_finstructed);
+  tGetPortsResult ports1;
+  GetPorts(*this->io_vector, ports1, ports_flagged_finstructed, origin);
+  tGetPortsResult ports2;
+  GetPorts(io_vector_, ports2, ports_flagged_finstructed, origin);
 
   for (size_t i = 0u; i < ports1.size(); i++)
   {
-    core::tAbstractPort* ap1 = ports1[i];
-    core::tAbstractPort* ap2 = i < ports2.size() ? ports2[i] : NULL;
-    CheckPort(ap2, io_vector_, flags_, ap1->GetName(), ap1->GetDataType(), ToPortCreateOptions(ap1->GetAllFlags(), selectable_create_options), ap1);
+    core::tAbstractPort* ap1 = ports1[i].second;
+    core::tAbstractPort* ap2 = i < ports2.size() ? ports2[i].second : nullptr;
+    CheckPort(ap2, io_vector_, flags_, ap1->GetName(), ap1->GetDataType(), ToPortCreateOptions(ap1->GetAllFlags(), selectable_create_options), ap1, i);
   }
   for (size_t i = ports1.size(); i < ports2.size(); i++)
   {
-    ports2[i]->ManagedDelete();
+    ports2[i].second->ManagedDelete();
   }
 }
 
 void tPortCreationList::CheckPort(core::tAbstractPort* existing_port, core::tFrameworkElement& io_vector, tFlags flags,
-                                  const std::string& name, rrlib::rtti::tType type, const tPortCreateOptions& create_options, core::tAbstractPort* prototype)
+                                  const std::string& name, rrlib::rtti::tType type, const tPortCreateOptions& create_options, core::tAbstractPort* prototype, size_t index)
 {
   if (existing_port && existing_port->GetName() == name && existing_port->GetDataType() == type &&
@@ -164 +166 @@
     bool create_output_port = create_options.Get(tPortCreateOption::OUTPUT) || flags.Get(tFlag::OUTPUT_PORT);
     bool create_shared_port = create_options.Get(tPortCreateOption::SHARED) || flags.Get(tFlag::SHARED);
+    auto annotation = existing_port->GetAnnotation<tOriginDataAnnotation>();
     if (((!selectable_create_options.Get(tPortCreateOption::OUTPUT)) || (existing_port->GetFlag(tFlag::OUTPUT_PORT) == create_output_port)) &&
-        ((!selectable_create_options.Get(tPortCreateOption::SHARED)) || (existing_port->GetFlag(tFlag::SHARED) == create_shared_port)))
+        ((!selectable_create_options.Get(tPortCreateOption::SHARED)) || (existing_port->GetFlag(tFlag::SHARED) == create_shared_port)) && annotation)
     {
       // port is as it should be
+      annotation->Data().order = index;  // possibly adjust index
       return;
     }
@@ -186 +190 @@
   FINROC_LOG_PRINT_TO(port_creation_list, DEBUG_VERBOSE_1, "Creating port ", name, " in IOVector ", io_vector);
   core::tAbstractPort* created_port = core::tPortFactory::CreatePort(name, io_vector, type, flags);
-  if (created_port != NULL)
-  {
+  if (created_port)
+  {
+    tOriginData origin_data;
+    origin_data.origin = origin;
+    origin_data.order = static_cast<tOriginData::tOrder>(index);
+    created_port->EmplaceAnnotation<tOriginDataAnnotation>(origin_data);
     created_port->Init();
   }
@@ -196 +204 @@
 }
 
-void tPortCreationList::GetPorts(const core::tFrameworkElement& elem, std::vector<core::tAbstractPort*>& result, bool finstructed_ports_only)
+void tPortCreationList::GetPorts(const core::tFrameworkElement& elem, tGetPortsResult& result, bool ports_flagged_finstructed, const tOrigin* origin)
 {
   result.clear();
   for (auto it = elem.ChildPortsBegin(); it != elem.ChildPortsEnd(); ++it)
   {
-    if ((!finstructed_ports_only) || it->GetFlag(tFlag::FINSTRUCTED))
-    {
-      result.push_back(&(*it));
-    }
+    tOriginDataAnnotation* origin_annotation = it->GetAnnotation<tOriginDataAnnotation>();
+    if (origin_annotation && ports_flagged_finstructed == it->GetFlag(tFlag::FINSTRUCTED) && origin_annotation->Data().origin == origin)
+    {
+      result.emplace_back(origin_annotation->Data().order, &(*it));
+    }
+  }
+
+  std::sort(result.begin(), result.end());
+
+  size_t expected_index = 0;
+  for (auto & entry : result)
+  {
+    if (static_cast<size_t>(entry.first) != expected_index)
+    {
+      FINROC_LOG_PRINT(WARNING, "Ports do not have expected indices. Adjusting.");
+      expected_index = 0;
+      for (auto & entry : result)
+      {
+        entry.second->GetAnnotation<tOriginDataAnnotation>()->Data().order = expected_index;
+        expected_index++;
+      }
+      break;
+    }
+    expected_index++;
   }
 }
@@ -215 +243 @@
   }
   int count = 0;
-  for (auto it = io_vector->ChildrenBegin(); it != io_vector->ChildrenEnd(); ++it)
-  {
-    count++;
+  for (auto it = io_vector->ChildPortsBegin(); it != io_vector->ChildPortsEnd(); ++it)
+  {
+    tOriginDataAnnotation* origin_annotation = it->GetAnnotation<tOriginDataAnnotation>();
+    if (origin_annotation && ports_flagged_finstructed == it->GetFlag(tFlag::FINSTRUCTED) && origin_annotation->Data().origin == origin)
+    {
+      count++;
+    }
   }
   return count;
@@ -224 +256 @@
 void tPortCreationList::InitialSetup(core::tFrameworkElement& managed_io_vector, tFlags port_creation_flags, const tPortCreateOptions& selectable_create_options)
 {
-  assert((io_vector == NULL || io_vector == &managed_io_vector) && list.empty());
+  assert((io_vector == nullptr || io_vector == &managed_io_vector) && list.empty());
   io_vector = &managed_io_vector;
   flags = port_creation_flags;
@@ -243 +275 @@
 {
   stream.WriteByte(list.selectable_create_options.Raw());
-  if (list.io_vector == NULL)
+  if (!list.io_vector)
   {
     int size = list.list.size();
@@ -258 +290 @@
   {
     rrlib::thread::tLock lock(list.io_vector->GetStructureMutex());
-    std::vector<core::tAbstractPort*> ports;
-    list.GetPorts(*list.io_vector, ports, list.ports_flagged_finstructed);
+    tPortCreationList::tGetPortsResult ports;
+    list.GetPorts(*list.io_vector, ports, list.ports_flagged_finstructed, list.origin);
     int size = ports.size();
     stream.WriteInt(size);
     for (int i = 0; i < size; i++)
     {
-      core::tAbstractPort* p = ports[i];
+      core::tAbstractPort* p = ports[i].second;
       stream.WriteString(p->GetName());
       stream.WriteString(p->GetDataType().GetName());
@@ -275 +307 @@
 rrlib::serialization::tInputStream& operator >> (rrlib::serialization::tInputStream& stream, tPortCreationList& list)
 {
-  if (list.io_vector == NULL)
+  if (!list.io_vector)
   {
     list.selectable_create_options = tPortCreateOptions(stream.ReadByte());
@@ -292 +324 @@
     stream.ReadByte(); // skip selectable create options, as this is not defined by finstruct
     size_t size = stream.ReadInt();
-    std::vector<core::tAbstractPort*> existing_ports;
-    list.GetPorts(*list.io_vector, existing_ports, list.ports_flagged_finstructed);
+    tPortCreationList::tGetPortsResult existing_ports;
+    list.GetPorts(*list.io_vector, existing_ports, list.ports_flagged_finstructed, list.origin);
     for (size_t i = 0u; i < size; i++)
     {
@@ -306 +338 @@
       tPortCreateOptions create_options(stream.ReadByte());
 
-      core::tAbstractPort* existing_port_with_this_name = NULL;
+      core::tAbstractPort* existing_port_with_this_name = nullptr;
       for (auto it = existing_ports.begin(); it != existing_ports.end(); ++it)
       {
-        if ((*it)->GetName() == name)
+        if (it->second->GetName() == name)
         {
-          existing_port_with_this_name = *it;
+          existing_port_with_this_name = it->second;
           existing_ports.erase(it);
           break;
         }
       }
-      list.CheckPort(existing_port_with_this_name, *list.io_vector, list.flags, name, type, create_options, NULL);
+      list.CheckPort(existing_port_with_this_name, *list.io_vector, list.flags, name, type, create_options, nullptr, i);
     }
 
@@ -322 +354 @@
     for (size_t i = 0; i < existing_ports.size(); i++)
     {
-      existing_ports[i]->ManagedDelete();
+      existing_ports[i].second->ManagedDelete();
     }
   }
@@ -340 +372 @@
     node.SetAttribute("showOutputSelection", list.selectable_create_options.Get(tPortCreateOption::OUTPUT));
   }
-  std::vector<core::tAbstractPort*> ports;
-  list.GetPorts(*list.io_vector, ports, list.ports_flagged_finstructed);
+  tPortCreationList::tGetPortsResult ports;
+  list.GetPorts(*list.io_vector, ports, list.ports_flagged_finstructed, list.origin);
   int size = ports.size();
   for (int i = 0; i < size; i++)
   {
-    core::tAbstractPort* p = ports[i];
+    core::tAbstractPort* p = ports[i].second;
     rrlib::xml::tNode& child = node.AddChildNode("port");
     child.SetAttribute("name", p->GetName());
@@ -370 +402 @@
 
   rrlib::thread::tLock lock(list.io_vector->GetStructureMutex());
-  if (!list.ports_flagged_finstructed)
+  if ((!list.ports_flagged_finstructed) && node.HasAttribute("showOutputSelection"))
   {
     list.selectable_create_options.Set(tPortCreateOption::OUTPUT, node.GetBoolAttribute("showOutputSelection"));
   }
-  std::vector<core::tAbstractPort*> ports;
-  list.GetPorts(*list.io_vector, ports, list.ports_flagged_finstructed);
+  tPortCreationList::tGetPortsResult ports;
+  list.GetPorts(*list.io_vector, ports, list.ports_flagged_finstructed, list.origin);
   size_t i = 0u;
   std::set<std::string> missing_types;
   for (rrlib::xml::tNode::const_iterator port = node.ChildrenBegin(); port != node.ChildrenEnd(); ++port, ++i)
   {
-    core::tAbstractPort* ap = i < ports.size() ? ports[i] : NULL;
+    core::tAbstractPort* ap = i < ports.size() ? ports[i].second : nullptr;
     std::string port_name = port->Name();
     assert(port_name.compare("port") == 0);
@@ -408 +440 @@
     }
 
-    list.CheckPort(ap, *list.io_vector, list.flags, port->GetStringAttribute("name"), dt, create_options, NULL);
+    list.CheckPort(ap, *list.io_vector, list.flags, port->GetStringAttribute("name"), dt, create_options, nullptr, i);
   }
   for (; i < ports.size(); i++)
   {
-    ports[i]->ManagedDelete();
+    ports[i].second->ManagedDelete();
   }
 

tPortCreationList.h

@@ -48 +48 @@
 //----------------------------------------------------------------------
 #include "plugins/runtime_construction/tDataTypeReference.h"
+#include "plugins/runtime_construction/tOriginData.h"
 
 //----------------------------------------------------------------------
@@ -102 +103 @@
 public:
 
+  typedef tOriginData::tOrigin tOrigin;
+
+
   tPortCreationList();
 
@@ -109 +113 @@
    * \param selectable_create_options Which creation options should be visible and selectable in finstruct?
    * \param ports_flagged_finstructed Deal only with ports flagged finstructed?
+   * \param origin Origin for which to create and manage ports (all ports that do no match origin are not touched)
    */
   tPortCreationList(core::tFrameworkElement& port_group, tFlags flags,
-                    const tPortCreateOptions& selectable_create_options, bool ports_flagged_finstructed = true);
+                    const tPortCreateOptions& selectable_create_options, bool ports_flagged_finstructed = true, const tOrigin* origin = nullptr);
 
   tPortCreationList(tPortCreationList &&) = delete;
@@ -170 +175 @@
   friend const rrlib::xml::tNode& operator >> (const rrlib::xml::tNode& node, tPortCreationList& list);
 
+  typedef std::vector<std::pair<tOriginData::tOrder, core::tAbstractPort*>> tGetPortsResult;
+
   /*!
    * Entry in list
@@ -211 +218 @@
    */
   bool ports_flagged_finstructed;
+
+  /*! Origin for which to create and manage ports (all ports that do no match origin are not touched) */
+  const tOrigin* origin;
 
   /*!
@@ -222 +232 @@
    * \param create_options Selected create options for port
    * \param prototype Port prototype (only interesting for listener)
+   * \param index Index for origin data
    */
   void CheckPort(core::tAbstractPort* existing_port, core::tFrameworkElement& io_vector, tFlags flags, const std::string& name,
-                 rrlib::rtti::tType type, const tPortCreateOptions& create_options, core::tAbstractPort* prototype);
-
-  /*!
-   * Returns all child ports of specified framework element
+                 rrlib::rtti::tType type, const tPortCreateOptions& create_options, core::tAbstractPort* prototype, size_t index);
+
+  /*!
+   * Returns all child ports of specified framework element with specified origin
    *
    * \param elem Framework Element
    * \param result List containing result
-   * \param finstructed_ports_only Only retrieve finstructed ports?
-   */
-  static void GetPorts(const core::tFrameworkElement& elem, std::vector<core::tAbstractPort*>& result, bool finstructed_ports_only);
+   * \param ports_flagged_finstructed Whether to return ports with FINSTRUCTED flag set - or without
+   * \param origin Origin ports must have
+   */
+  static void GetPorts(const core::tFrameworkElement& elem, tGetPortsResult& result, bool ports_flagged_finstructed, const tOrigin* origin);
 };