diff --git a/src/netedit/elements/GNEAttributeCarrier.cpp b/src/netedit/elements/GNEAttributeCarrier.cpp
index 8fc2afea9a3..06843c87f57 100644
--- a/src/netedit/elements/GNEAttributeCarrier.cpp
+++ b/src/netedit/elements/GNEAttributeCarrier.cpp
@@ -385,8 +385,9 @@ GNEAttributeCarrier::parse(const std::string& value) {
 template<> std::vector<GNEEdge*>
 GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
     // Declare string vector
-    std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
+    const auto edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
     std::vector<GNEEdge*> parsedEdges;
+    parsedEdges.reserve(edgeIds.size());
     // Iterate over edges IDs, retrieve Edges and add it into parsedEdges
     for (const auto& edgeID : edgeIds) {
         GNEEdge* retrievedEdge = net->getAttributeCarriers()->retrieveEdge(edgeID, false);
@@ -401,11 +402,18 @@ GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
 }
 
 
+template<> GNEHierarchicalContainerChildren<GNEEdge*>
+GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
+    return GNEHierarchicalContainerChildren<GNEEdge*>(parse<std::vector<GNEEdge*> >(net, value));
+}
+
+
 template<> std::vector<GNELane*>
 GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
     // Declare string vector
-    std::vector<std::string> laneIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
+    const auto laneIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
     std::vector<GNELane*> parsedLanes;
+    parsedLanes.reserve(laneIds.size());
     // Iterate over lanes IDs, retrieve Lanes and add it into parsedLanes
     for (const auto& laneID : laneIds) {
         GNELane* retrievedLane = net->getAttributeCarriers()->retrieveLane(laneID, false);
@@ -420,6 +428,12 @@ GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
 }
 
 
+template<> GNEHierarchicalContainerChildren<GNELane*>
+GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
+    return GNEHierarchicalContainerChildren<GNELane*>(parse<std::vector<GNELane*> >(net, value));
+}
+
+
 template<> std::string
 GNEAttributeCarrier::parseIDs(const std::vector<GNEEdge*>& ACs) {
     // obtain ID's of edges and return their join
diff --git a/src/netedit/elements/GNEHierarchicalContainerChildrenHash.h b/src/netedit/elements/GNEHierarchicalContainerChildrenHash.h
index 484cfcc74c8..7863d09a2e6 100644
--- a/src/netedit/elements/GNEHierarchicalContainerChildrenHash.h
+++ b/src/netedit/elements/GNEHierarchicalContainerChildrenHash.h
@@ -20,14 +20,14 @@
 #pragma once
 #include <config.h>
 
-#include <unordered_set>
+#include <set>
 
 // ===========================================================================
 // class definitions
 // ===========================================================================
 
 template <typename T> 
-class GNEHierarchicalContainerChildrenHash : public std::unordered_set<T> {
+class GNEHierarchicalContainerChildrenHash : public std::set<T> {
 
 public:
     /// @brief default constructor
@@ -35,7 +35,7 @@ class GNEHierarchicalContainerChildrenHash : public std::unordered_set<T> {
     }
 
     /// @brief parameter constructor
-    GNEHierarchicalContainerChildrenHash(const std::unordered_set<T>& elements) :
-        std::unordered_set<T>(elements) {
+    GNEHierarchicalContainerChildrenHash(const std::set<T>& elements) :
+        std::set<T>(elements) {
     }
 };
diff --git a/src/netedit/elements/GNEHierarchicalElement.h b/src/netedit/elements/GNEHierarchicalElement.h
index 83cd789b006..2f5e6660ca1 100644
--- a/src/netedit/elements/GNEHierarchicalElement.h
+++ b/src/netedit/elements/GNEHierarchicalElement.h
@@ -196,7 +196,7 @@ class GNEHierarchicalElement : public GNEAttributeCarrier {
 
     /// @brief replace children in the given edited element 
     template<typename T, typename U>
-    void replaceChildElements(T* editedElement, const std::vector<U>& newChildren) {
+    void replaceChildElements(T* editedElement, const GNEHierarchicalContainerChildren<U>& newChildren) {
         // remove edited elements from children
         for (const auto& child : myHierarchicalStructure.getChildren<U>()) {
             child->removeChildElement(editedElement);
diff --git a/src/netedit/elements/GNEHierarchicalStructure.cpp b/src/netedit/elements/GNEHierarchicalStructure.cpp
index 8b931305243..761d1eb1efd 100644
--- a/src/netedit/elements/GNEHierarchicalStructure.cpp
+++ b/src/netedit/elements/GNEHierarchicalStructure.cpp
@@ -437,43 +437,43 @@ GNEHierarchicalStructure::getChildren() const {
 
 
 template<> void
-GNEHierarchicalStructure::setChildren(const std::vector<GNEJunction*>& newChildren) {
+GNEHierarchicalStructure::setChildren(const GNEHierarchicalContainerChildren<GNEJunction*>& newChildren) {
     myChildJunctions = newChildren;
 }
 
 
 template<> void
-GNEHierarchicalStructure::setChildren(const std::vector<GNEEdge*>& newChildren) {
+GNEHierarchicalStructure::setChildren(const GNEHierarchicalContainerChildren<GNEEdge*>& newChildren) {
     myChildEdges = newChildren;
 }
 
 
 template<> void
-GNEHierarchicalStructure::setChildren(const std::vector<GNELane*>& newChildren) {
+GNEHierarchicalStructure::setChildren(const GNEHierarchicalContainerChildren<GNELane*>& newChildren) {
     myChildLanes = newChildren;
 }
 
 
 template<> void
-GNEHierarchicalStructure::setChildren(const std::vector<GNEAdditional*>& newChildren) {
+GNEHierarchicalStructure::setChildren(const GNEHierarchicalContainerChildren<GNEAdditional*>& newChildren) {
     myChildAdditionals = newChildren;
 }
 
 
 template<> void
-GNEHierarchicalStructure::setChildrenHash(const std::unordered_set<GNETAZSourceSink*>& newChildren) {
+GNEHierarchicalStructure::setChildrenHash(const GNEHierarchicalContainerChildrenHash<GNETAZSourceSink*>& newChildren) {
     myChildSourceSinks = newChildren;
 }
 
 
 template<> void
-GNEHierarchicalStructure::setChildren(const std::vector<GNEDemandElement*>& newChildren) {
+GNEHierarchicalStructure::setChildren(const GNEHierarchicalContainerChildren<GNEDemandElement*>& newChildren) {
     myChildDemandElements = newChildren;
 }
 
 
 template<> void
-GNEHierarchicalStructure::setChildren(const std::vector<GNEGenericData*>& newChildren) {
+GNEHierarchicalStructure::setChildren(const GNEHierarchicalContainerChildren<GNEGenericData*>& newChildren) {
     myChildGenericDatas = newChildren;
 }
 
diff --git a/src/netedit/elements/GNEHierarchicalStructure.h b/src/netedit/elements/GNEHierarchicalStructure.h
index 388e2f90656..40ee3bee00c 100644
--- a/src/netedit/elements/GNEHierarchicalStructure.h
+++ b/src/netedit/elements/GNEHierarchicalStructure.h
@@ -97,11 +97,11 @@ class GNEHierarchicalStructure {
 
     /// @brief set children
     template<typename T>
-    void setChildren(const std::vector<T>& newChildren);
+    void setChildren(const GNEHierarchicalContainerChildren<T>& newChildren);
 
     /// @brief set children hash
     template<typename T>
-    void setChildrenHash(const std::unordered_set<T>& newChildren);
+    void setChildrenHash(const GNEHierarchicalContainerChildrenHash<T>& newChildren);
 
 private:
     /// @brief parents junctions
diff --git a/src/netedit/elements/additional/GNEAdditional.cpp b/src/netedit/elements/additional/GNEAdditional.cpp
index 8f1a335156d..fa85ca57df0 100644
--- a/src/netedit/elements/additional/GNEAdditional.cpp
+++ b/src/netedit/elements/additional/GNEAdditional.cpp
@@ -664,13 +664,13 @@ GNEAdditional::replaceAdditionalParentLanes(const std::string& value) {
 
 void
 GNEAdditional::replaceAdditionalChildEdges(const std::string& value) {
-    replaceChildElements(this, parse<std::vector<GNEEdge*> >(getNet(), value));
+    replaceChildElements(this, parse<GNEHierarchicalContainerChildren<GNEEdge*> >(getNet(), value));
 }
 
 
 void
 GNEAdditional::replaceAdditionalChildLanes(const std::string& value) {
-    replaceChildElements(this, parse<std::vector<GNELane*> >(getNet(), value));
+    replaceChildElements(this, parse<GNEHierarchicalContainerChildren<GNELane*> >(getNet(), value));
 }