GNEHierarchicalElement.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 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
/****************************************************************************/
// A abstract class for representation of hierarchical elements
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "GNEHierarchicalStructureParents.h"
#include "GNEHierarchicalStructureChildren.h"
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEHierarchicalElement {
 
public:
    friend class GNEChange_Children;
    friend class GNEDemandElement;
 
    GNEHierarchicalElement();
 
    ~GNEHierarchicalElement();
 
    void clearParents();
 
 
    const GNEHierarchicalStructureParents& getParents() const;
 
    const GNEHierarchicalContainerParents<GNEJunction*>& getParentJunctions() const;
 
    const GNEHierarchicalContainerParents<GNEEdge*>& getParentEdges() const;
 
    const GNEHierarchicalContainerParents<GNELane*>& getParentLanes() const;
 
    const GNEHierarchicalContainerParents<GNEAdditional*>& getParentAdditionals() const;
 
    const GNEHierarchicalContainerParents<GNEAdditional*> getParentStoppingPlaces() const;
 
    const GNEHierarchicalContainerParents<GNEAdditional*> getParentTAZs() const;
 
    const GNEHierarchicalContainerParents<GNEDemandElement*>& getParentDemandElements() const;
 
    const GNEHierarchicalContainerParents<GNEGenericData*>& getParentGenericDatas() const;
 
 
 
    const GNEHierarchicalStructureChildren& getChildren() const;
 
    const GNEHierarchicalContainerChildren<GNEJunction*>& getChildJunctions() const;
 
    const GNEHierarchicalContainerChildren<GNEEdge*>& getChildEdges() const;
 
    const GNEHierarchicalContainerChildren<GNELane*>& getChildLanes() const;
 
    const GNEHierarchicalContainerChildren<GNEAdditional*>& getChildAdditionals() const;
 
    const GNEHierarchicalContainerChildren<GNEDemandElement*>& getChildDemandElements() const;
 
    const GNEHierarchicalContainerChildren<GNEGenericData*>& getChildGenericDatas() const;
 
    const GNEHierarchicalContainerChildrenSet<GNETAZSourceSink*>& getChildTAZSourceSinks() const;
 
 
 
    template<typename ParentType>
    void setParent(ParentType parent) {
        GNEHierarchicalContainerParents<ParentType> parents;
        parents.push_back(parent);
        myHierarchicalStructureParents.replaceAll(parents);
    }
 
    template<typename ParentType>
    void setParents(const GNEHierarchicalContainerParents<ParentType>& parents) {
        myHierarchicalStructureParents.replaceAll(parents);
    }
 
    template<typename ChildType>
    void addChildElement(ChildType* element) {
        myHierarchicalStructureChildren.add(element);
    }
 
    template<typename ChildType>
    void sortChildren(std::vector<ChildType*> sortedChildrens) {
        // remove elements and add again
        for (auto child : sortedChildrens) {
            myHierarchicalStructureChildren.remove(child);
        }
        for (auto child : sortedChildrens) {
            myHierarchicalStructureChildren.add(child);
        }
    }
 
 
 
    template<typename ElementType, typename ParentType>
    static void insertParent(ElementType* element, ParentType* parent, const int index = -1) {
        element->myHierarchicalStructureParents.add(parent, index);
        parent->myHierarchicalStructureChildren.add(element);
    }
 
    template<typename ElementType, typename ParentType>
    static void removeParent(ElementType* element, ParentType* parent) {
        element->myHierarchicalStructureParents.remove(parent);
        parent->myHierarchicalStructureChildren.remove(element);
    }
 
    template<typename ElementType, typename ParentType>
    static void updateParent(ElementType element, const int index, ParentType newParent) {
        // remove element from old parent
        auto oldParent = element->myHierarchicalStructureParents.template at<ParentType>(index);
        if (oldParent) {
            oldParent->myHierarchicalStructureChildren.remove(element);
        }
        // update parent
        element->myHierarchicalStructureParents.replaceSingle(index, newParent);
        // insert child in new parent
        if (newParent) {
            newParent->myHierarchicalStructureChildren.add(element);
        }
    }
 
    template<typename ElementType, typename ParentType>
    static void updateParents(ElementType element, GNEHierarchicalContainerParents<ParentType> newParents) {
        // remove children
        for (const auto parent : element->myHierarchicalStructureParents.template get<ParentType>()) {
            if (parent) {
                parent->myHierarchicalStructureChildren.remove(element);
            }
        }
        // update parents
        element->myHierarchicalStructureParents.replaceAll(newParents);
        // restore children
        for (const auto parent : element->myHierarchicalStructureParents.template get<ParentType>()) {
            if (parent) {
                parent->myHierarchicalStructureChildren.add(element);
            }
        }
    }
 
    template<typename ElementType, typename ChildType>
    static void insertChild(ElementType element, ChildType child) {
        if (element) {
            element->myHierarchicalStructureChildren.add(child);
        }
        if (child) {
            child->myHierarchicalStructureParents.add(element);
        }
    }
 
    template<typename ElementType, typename ChildType>
    static void removeChild(ElementType element, ChildType child) {
        if (element) {
            element->myHierarchicalStructureChildren.remove(child);
        }
        if (child) {
            child->myHierarchicalStructureParents.remove(element);
        }
    }
 
    template<typename ElementType, typename ChildType>
    static void updateChildren(ElementType element, GNEHierarchicalContainerChildren<ChildType> newChildren) {
        // remove children
        for (const auto children : element->myHierarchicalStructureChildren.template get<ChildType>()) {
            if (children) {
                children->myHierarchicalStructureParents.remove(element);
            }
        }
        // update children
        element->myHierarchicalStructureChildren.replaceAll(newChildren);
        // restore children
        for (const auto children : element->myHierarchicalStructureChildren.template get<ChildType>()) {
            if (children) {
                children->myHierarchicalStructureParents.add(element);
            }
        }
    }
 
 
 
    std::string getNewListOfParents(const GNENetworkElement* currentElement, const GNENetworkElement* newNextElement) const;
 
 
private:
    GNEHierarchicalStructureParents myHierarchicalStructureParents;
 
    GNEHierarchicalStructureChildren myHierarchicalStructureChildren;
 
    GNEHierarchicalElement(const GNEHierarchicalElement&) = delete;
};