GNEHierarchicalElement.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 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 <utils/gui/div/GUIGeometry.h>
#include <netedit/elements/GNEAttributeCarrier.h>
 
#include "GNEHierarchicalContainer.h"
 
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEHierarchicalElement : public GNEAttributeCarrier {
 
public:
    friend class GNEChange_Children;
    friend class GNEDemandElement;
 
    GNEHierarchicalElement(GNENet* net, SumoXMLTag tag,
                           const std::vector<GNEJunction*>& parentJunctions,
                           const std::vector<GNEEdge*>& parentEdges,
                           const std::vector<GNELane*>& parentLanes,
                           const std::vector<GNEAdditional*>& parentAdditionals,
                           const std::vector<GNEDemandElement*>& parentDemandElements,
                           const std::vector<GNEGenericData*>& parentGenericDatas);
 
    ~GNEHierarchicalElement();
 
    GNEHierarchicalElement* getHierarchicalElement() {
        return this;
    }
 
    virtual void updateGeometry() = 0;
 
    virtual Position getPositionInView() const = 0;
 
    const GNEHierarchicalContainer& getHierarchicalContainer() const;
 
    void restoreHierarchicalContainer(const GNEHierarchicalContainer& container);
 
 
    std::vector<GNEHierarchicalElement*> getAllHierarchicalElements() const;
 
    const std::vector<GNEJunction*>& getParentJunctions() const;
 
    const std::vector<GNEEdge*>& getParentEdges() const;
 
    const std::vector<GNELane*>& getParentLanes() const;
 
    const std::vector<GNEAdditional*>& getParentAdditionals() const;
 
    const std::vector<GNEDemandElement*>& getParentDemandElements() const;
 
    const std::vector<GNEGenericData*>& getParentGenericDatas() const;
 
    const std::vector<GNEJunction*>& getChildJunctions() const;
 
    const std::vector<GNEEdge*>& getChildEdges() const;
 
    const std::vector<GNELane*>& getChildLanes() const;
 
    const std::vector<GNEAdditional*>& getChildAdditionals() const;
 
    const std::vector<GNEDemandElement*>& getChildDemandElements() const;
 
    const std::vector<GNEGenericData*>& getChildGenericDatas() const;
 
 
    template<typename T>
    void addParentElement(T* element);
 
    template<typename T>
    void removeParentElement(T* element);
 
    template<typename T>
    void addChildElement(T* element);
 
    template<typename T>
    void removeChildElement(T* element);
 
 
    std::string getNewListOfParents(const GNENetworkElement* currentElement, const GNENetworkElement* newNextElement) const;
 
 
    bool checkChildAdditionalsOverlapping() const;
 
    bool checkChildDemandElementsOverlapping() const;
 
protected:
    template<typename T, typename U>
    void replaceParentElements(T* elementChild, const U& newParents) {
        // remove elementChild from parents
        for (const auto& parent : myHierarchicalContainer.getParents<U>()) {
            parent->removeChildElement(elementChild);
        }
        // set new parents junctions
        myHierarchicalContainer.setParents(newParents);
        // add elementChild into new parents
        for (const auto& parent : myHierarchicalContainer.getParents<U>()) {
            parent->addChildElement(elementChild);
        }
    }
 
    template<typename T, typename U>
    void replaceChildElements(T* elementChild, const U& newChildren) {
        // remove elementChild from childs
        for (const auto& child : myHierarchicalContainer.getChildren<U>()) {
            child->removeChildElement(elementChild);
        }
        // set new childs junctions
        myHierarchicalContainer.setChildren(newChildren);
        // add elementChild into new childs
        for (const auto& child : myHierarchicalContainer.getChildren<U>()) {
            child->addChildElement(elementChild);
        }
    }
 
private:
    GNEHierarchicalContainer myHierarchicalContainer;
 
    GNEHierarchicalElement(const GNEHierarchicalElement&) = delete;
 
    GNEHierarchicalElement& operator=(const GNEHierarchicalElement&) = delete;
};