GNEHierarchicalParentElements.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2020 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 <netedit/GNEGeometry.h>
#include <utils/gui/globjects/GUIGlObjectTypes.h>
#include <utils/geom/Position.h>

#include "GNEAttributeCarrier.h"

// ===========================================================================
// class declarations
// ===========================================================================

class GNENetworkElement;
class GNEAdditional;
class GNETAZElement;
class GNEShape;
class GNEDemandElement;
class GNEGenericData;

// ===========================================================================
// class definitions
// ===========================================================================

class GNEHierarchicalParentElements {

public:

    friend class GNEChange_Children;

    GNEHierarchicalParentElements(const GNEAttributeCarrier* AC,
        const std::vector<GNEJunction*>& parentJunctions,
        const std::vector<GNEEdge*>& parentEdges,
        const std::vector<GNELane*>& parentLanes,
        const std::vector<GNEAdditional*>& parentAdditionals,
        const std::vector<GNEShape*>& parentShapes,
        const std::vector<GNETAZElement*>& parentTAZElements,
        const std::vector<GNEDemandElement*>& parentDemandElements,
        const std::vector<GNEGenericData*>& parentGenericDatas);

    ~GNEHierarchicalParentElements();

    virtual void updateGeometry() = 0;

    virtual Position getPositionInView() const = 0;

    template<typename T>
    void addParentElement(T* element);

    template<typename T>
    void removeParentElement(T* element);

    const std::vector<GNEEdge*>& getParentEdges() const;

    const std::vector<GNELane*>& getParentLanes() const;

    const std::vector<GNEAdditional*>& getParentAdditionals() const;

    const std::vector<GNEShape*>& getParentShapes() const;

    const std::vector<GNETAZElement*>& getParentTAZElements() const;

    const std::vector<GNEDemandElement*>& getParentDemandElements() const;

    const std::vector<GNEGenericData*>& getParentGenericDatas() const;

    GNEJunction* getFirstParentJunction() const;

    GNEJunction* getSecondParentJunction()const ;

    void updateFirstParentJunction(GNEJunction* junction);

    void updateSecondParentJunction(GNEJunction* junction);

    std::vector<GNEEdge*> getMiddleParentEdges() const;

    std::string getNewListOfParents(const GNENetworkElement* currentElement, const GNENetworkElement* newNextElement) const;

protected:

    void replaceParentEdges(GNEShape* elementChild, const std::string& newEdgeIDs);

    void replaceParentEdges(GNEAdditional* elementChild, const std::string& newEdgeIDs);

    void replaceParentEdges(GNEDemandElement* elementChild, const std::string& newEdgeIDs);

    void replaceParentEdges(GNEDemandElement* elementChild, const std::vector<GNEEdge*>& newEdges);

    void replaceParentEdges(GNEGenericData* elementChild, const std::vector<GNEEdge*>& newEdges);

    void replaceFirstParentEdge(GNEDemandElement* elementChild, GNEEdge* newFirstEdge);

    void replaceFirstParentEdge(GNEGenericData* elementChild, GNEEdge* newFirstEdge);

    void replaceMiddleParentEdges(GNEDemandElement* elementChild, const std::vector<GNEEdge*>& newMiddleEdges, const bool updateChildReferences);

    void replaceLastParentEdge(GNEDemandElement* elementChild, GNEEdge* newLastEdge);

    void replaceLastParentEdge(GNEGenericData* elementChild, GNEEdge* newLastEdge);

    void replaceParentLanes(GNEShape* elementChild, const std::string& newLaneIDs);

    void replaceParentLanes(GNEAdditional* elementChild, const std::string& newLaneIDs);

    void replaceParentLanes(GNEDemandElement* elementChild, const std::string& newLaneIDs);

    void replaceParentAdditional(GNEShape* shapeTobeChanged, const std::string& newParentAdditionalID, int additionalParentIndex);

    void replaceParentAdditional(GNEAdditional* additionalTobeChanged, const std::string& newParentAdditionalID, int additionalParentIndex);

    void replaceParentAdditional(GNEDemandElement* demandElementTobeChanged, const std::string& newParentAdditionalID, int additionalParentIndex);

    void replaceFirstParentTAZElement(GNEGenericData* elementChild, GNETAZElement* newFirstTAZElement);

    void replaceLastParentTAZElement(GNEGenericData* elementChild, GNETAZElement* newLastTAZElement);

    void replaceParentDemandElement(GNEShape* shapeTobeChanged, const std::string& newParentDemandElementID, int demandElementParentIndex);

    void replaceParentDemandElement(GNEAdditional* additionalTobeChanged, const std::string& newParentDemandElementID, int demandElementParentIndex);

    void replaceParentDemandElement(GNEDemandElement* demandElementTobeChanged, const std::string& newParentDemandElementID, int demandElementParentIndex);


    GNEGeometry::ParentConnections myParentConnections;

private:
    std::vector<GNEJunction*> myParentJunctions;

    std::vector<GNEEdge*> myParentEdges;

    std::vector<GNELane*> myParentLanes;

    std::vector<GNEAdditional*> myParentAdditionals;

    std::vector<GNEShape*> myParentShapes;

    std::vector<GNETAZElement*> myParentTAZElements;

    std::vector<GNEDemandElement*> myParentDemandElements;

    std::vector<GNEGenericData*> myParentGenericDatas;

    const GNEAttributeCarrier* myAC;

    GNEHierarchicalParentElements(const GNEHierarchicalParentElements&) = delete;

    GNEHierarchicalParentElements& operator=(const GNEHierarchicalParentElements&) = delete;
};