GNEHierarchicalChildElements.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 <utils/gui/globjects/GUIGlObjectTypes.h>

#include "GNEAttributeCarrier.h"

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

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

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

class GNEHierarchicalChildElements {

public:

    friend class GNEChange_Children;

    GNEHierarchicalChildElements(const GNEAttributeCarrier* AC,
        const std::vector<GNEJunction*>& childJunctions,
        const std::vector<GNEEdge*>& childEdges,
        const std::vector<GNELane*>& childLanes,
        const std::vector<GNEAdditional*>& childAdditionals,
        const std::vector<GNEShape*>& childShapes,
        const std::vector<GNETAZElement*>& childTAZElements,
        const std::vector<GNEDemandElement*>& childDemandElements,
        const std::vector<GNEGenericData*>& childGenericDataElements);

    ~GNEHierarchicalChildElements();

    const Position& getChildPosition(const GNELane* lane);

    double getChildRotation(const GNELane* lane);

    void updateChildConnections();

    void drawChildConnections(const GUIVisualizationSettings& s, const GUIGlObjectType GLTypeParent, const double exaggeration) const;

    void drawChildDottedConnections(const GUIVisualizationSettings& s, const double exaggeration) const;

    virtual void updateGeometry() = 0;

    virtual Position getPositionInView() const = 0;

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

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

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

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

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

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

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

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

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

    void sortChildAdditionals();

    bool checkChildAdditionalsOverlapping() const;

    const std::vector<GNEDemandElement*>& getChildDemandElementsByType(SumoXMLTag tag) const;

    void sortChildDemandElements();

    bool checkChildDemandElementsOverlapping() const;

    GNEDemandElement* getPreviousChildDemandElement(const GNEDemandElement* demandElement) const;

    GNEDemandElement* getNextChildDemandElement(const GNEDemandElement* demandElement) const;


    virtual void updateParentAdditional();

    virtual void updateParentDemandElement();

protected:

    class ChildConnections {

    private:
        class ConnectionGeometry {

        public:
            ConnectionGeometry(GNELane* lane);

            const GNELane* getLane() const;
            
            const Position &getPosition() const;

            double getRotation() const;

        private:
            GNELane* myLane;

            Position myPosition;

            double myRotation;

            ConnectionGeometry();
        };

    public:
        ChildConnections(GNEHierarchicalChildElements* hierarchicalElement);

        void update();

        void drawConnection(const GUIVisualizationSettings& s, const GUIGlObjectType parentType, const double exaggeration) const;

        void drawDottedConnection(const GUIVisualizationSettings& s, const double exaggeration) const;

        std::vector<ConnectionGeometry> symbolsPositionAndRotation;

        std::vector<GNEGeometry::Geometry> connectionsGeometries;

    private:
        GNEHierarchicalChildElements* myHierarchicalElement;
    };

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

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

    ChildConnections myChildConnections;

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

    std::vector<GNEEdge*> myChildEdges;

    std::vector<GNELane*> myChildLanes;

    std::vector<GNEAdditional*> myChildAdditionals;

    std::vector<GNEShape*> myChildShapes;

    std::vector<GNETAZElement*> myChildTAZElements;

    std::vector<GNEDemandElement*> myChildDemandElements;

    std::vector<GNEGenericData*> myChildGenericDataElements;

    std::map<SumoXMLTag, std::vector<GNEDemandElement* >> myDemandElementsByType;

    const GNEAttributeCarrier* myAC;

    GNEHierarchicalChildElements(const GNEHierarchicalChildElements&) = delete;

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