GNEHierarchicalStructureChildren.cpp

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Structure for // Structure for GNEHierarchicalElements centered in children
/****************************************************************************/
 
#include <netedit/elements/network/GNEJunction.h>
#include <netedit/elements/network/GNEEdge.h>
#include <netedit/elements/network/GNELane.h>
#include <netedit/elements/demand/GNEDemandElement.h>
#include <netedit/elements/additional/GNEAdditional.h>
#include <netedit/elements/additional/GNETAZSourceSink.h>
#include <netedit/elements/data/GNEGenericData.h>
#include <utils/common/UtilExceptions.h>
 
#include "GNEHierarchicalStructureChildren.h"
 
// ===========================================================================
// member method definitions
// ===========================================================================
 
GNEHierarchicalStructureChildren::GNEHierarchicalStructureChildren() {}
 
// get functions
 
template<> const GNEHierarchicalContainerChildren<GNEJunction*>&
GNEHierarchicalStructureChildren::get() const {
    return myChildJunctions;
}
GNEHierarchicalStructureChildren::get() const  {…}
 
 
template<> const GNEHierarchicalContainerChildren<GNEEdge*>&
GNEHierarchicalStructureChildren::get() const {
    return myChildEdges;
}
GNEHierarchicalStructureChildren::get() const  {…}
 
 
template<> const GNEHierarchicalContainerChildren<GNELane*>&
GNEHierarchicalStructureChildren::get() const {
    return myChildLanes;
}
GNEHierarchicalStructureChildren::get() const  {…}
 
 
template<> const GNEHierarchicalContainerChildren<GNEAdditional*>&
GNEHierarchicalStructureChildren::get() const {
    return myChildAdditionals;
}
GNEHierarchicalStructureChildren::get() const  {…}
 
 
template<> const GNEHierarchicalContainerChildren<GNEDemandElement*>&
GNEHierarchicalStructureChildren::get() const {
    return myChildDemandElements;
}
GNEHierarchicalStructureChildren::get() const  {…}
 
 
template<> const GNEHierarchicalContainerChildren<GNEGenericData*>&
GNEHierarchicalStructureChildren::get() const {
    return myChildGenericDatas;
}
GNEHierarchicalStructureChildren::get() const  {…}
 
 
template<> const GNEHierarchicalContainerChildrenSet<GNETAZSourceSink*>&
GNEHierarchicalStructureChildren::getSet() const {
    return myChildSourceSinks;
}
GNEHierarchicalStructureChildren::getSet() const  {…}
 
// add functions
 
template <> void
GNEHierarchicalStructureChildren::add(GNEJunction* child) {
    myChildJunctions.push_back(child);
}
GNEHierarchicalStructureChildren::add(GNEJunction* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::add(GNEEdge* child) {
    myChildEdges.push_back(child);
}
GNEHierarchicalStructureChildren::add(GNEEdge* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::add(GNELane* child) {
    myChildLanes.push_back(child);
}
GNEHierarchicalStructureChildren::add(GNELane* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::add(GNEAdditional* child) {
    myChildAdditionals.push_back(child);
}
GNEHierarchicalStructureChildren::add(GNEAdditional* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::add(GNETAZSourceSink* child) {
    myChildSourceSinks.insert(child);
}
GNEHierarchicalStructureChildren::add(GNETAZSourceSink* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::add(GNEDemandElement* child) {
    myChildDemandElements.push_back(child);
}
GNEHierarchicalStructureChildren::add(GNEDemandElement* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::add(GNEGenericData* child) {
    myChildGenericDatas.push_back(child);
}
GNEHierarchicalStructureChildren::add(GNEGenericData* child) {…}
 
// remove functions
 
template <> void
GNEHierarchicalStructureChildren::remove(GNEJunction* child) {
    auto it = std::find(myChildJunctions.begin(), myChildJunctions.end(), child);
    if (it != myChildJunctions.end()) {
        myChildJunctions.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNEJunction* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::remove(GNEEdge* child) {
    auto it = std::find(myChildEdges.begin(), myChildEdges.end(), child);
    if (it != myChildEdges.end()) {
        myChildEdges.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNEEdge* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::remove(GNELane* child) {
    auto it = std::find(myChildLanes.begin(), myChildLanes.end(), child);
    if (it != myChildLanes.end()) {
        myChildLanes.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNELane* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::remove(GNEAdditional* child) {
    auto it = std::find(myChildAdditionals.begin(), myChildAdditionals.end(), child);
    if (it != myChildAdditionals.end()) {
        myChildAdditionals.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNEAdditional* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::remove(GNETAZSourceSink* child) {
    auto it = myChildSourceSinks.find(child);
    if (it != myChildSourceSinks.end()) {
        myChildSourceSinks.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNETAZSourceSink* child) {…}
 
template <> void
GNEHierarchicalStructureChildren::remove(GNEDemandElement* child) {
    auto it = std::find(myChildDemandElements.begin(), myChildDemandElements.end(), child);
    if (it != myChildDemandElements.end()) {
        myChildDemandElements.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNEDemandElement* child) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::remove(GNEGenericData* child) {
    auto it = std::find(myChildGenericDatas.begin(), myChildGenericDatas.end(), child);
    if (it != myChildGenericDatas.end()) {
        myChildGenericDatas.erase(it);
    } else {
        throw ProcessError(child->getTagStr() + " is not a child element");
    }
}
GNEHierarchicalStructureChildren::remove(GNEGenericData* child) {…}
 
// replaceAll functions
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEJunction*>& children) {
    myChildJunctions = children;
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEJunction*>& children) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEEdge*>& children) {
    myChildEdges = children;
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEEdge*>& children) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNELane*>& children) {
    myChildLanes = children;
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNELane*>& children) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEAdditional*>& children) {
    myChildAdditionals = children;
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEAdditional*>& children) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNETAZSourceSink*>& children) {
    myChildSourceSinks.clear();
    for (const auto child : children) {
        myChildSourceSinks.insert(child);
    }
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNETAZSourceSink*>& children) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEDemandElement*>& children) {
    myChildDemandElements = children;
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEDemandElement*>& children) {…}
 
 
template <> void
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEGenericData*>& children) {
    myChildGenericDatas = children;
}
GNEHierarchicalStructureChildren::replaceAll(const GNEHierarchicalContainerChildren<GNEGenericData*>& children) {…}
 
/****************************************************************************/