NBTypeCont.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 storage for available edgeTypes of edges
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <utils/common/SUMOVehicleClass.h>
#include <netbuild/NBEdge.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBTypeCont {
 
public:
    struct EdgeTypeDefinition;
 
    struct LaneTypeDefinition {
 
        LaneTypeDefinition();
 
        LaneTypeDefinition(const EdgeTypeDefinition* edgeTypeDefinition);
 
        LaneTypeDefinition(const double speed, const double friction, const double width, SVCPermissions permissions, const std::set<SumoXMLAttr>& attrs);
 
        LaneTypeDefinition(const LaneTypeDefinition* laneTypeDefinition);
 
        double speed;
 
        double friction;
 
        SVCPermissions permissions;
 
        double width;
 
        std::map<SUMOVehicleClass, double> restrictions;
 
        std::set<SumoXMLAttr> attrs;
    };
 
    struct EdgeTypeDefinition {
 
        EdgeTypeDefinition();
 
        EdgeTypeDefinition(const EdgeTypeDefinition* edgeType);
 
        EdgeTypeDefinition(int numLanes, double speed, double friction, int priority,
                           double width, SVCPermissions permissions, LaneSpreadFunction spreadType,
                           bool oneWay, double sideWalkWidth, double bikeLaneWidth,
                           double widthResolution, double maxWidth, double minWidth);
 
        bool needsLaneType() const;
 
        double speed;
 
        double friction;
 
        int priority;
 
        SVCPermissions permissions;
 
        LaneSpreadFunction spreadType;
 
        bool oneWay;
 
        bool discard;
 
        double width;
 
        double widthResolution;
 
        double maxWidth;
 
        double minWidth;
 
        /* @brief The width of the sidewalk that should be added as an additional lane
        * a value of NBEdge::UNSPECIFIED_WIDTH indicates that no sidewalk should be added */
        double sidewalkWidth;
 
        /* @brief The width of the bike lane that should be added as an additional lane
        * a value of NBEdge::UNSPECIFIED_WIDTH indicates that no bike lane should be added */
        double bikeLaneWidth;
 
        std::map<SUMOVehicleClass, double> restrictions;
 
        std::set<SumoXMLAttr> attrs;
 
        std::vector<LaneTypeDefinition> laneTypeDefinitions;
    };
 
    typedef std::map<std::string, EdgeTypeDefinition*> TypesCont;
 
    NBTypeCont();
 
    ~NBTypeCont();
 
    void clearTypes();
 
    void setEdgeTypeDefaults(int defaultNumLanes, double defaultLaneWidth,
                             double defaultSpeed, double defaultFriction, int defaultPriority,
                             SVCPermissions defaultPermissions,
                             LaneSpreadFunction defaultSpreadType);
 
    void insertEdgeType(const std::string& id, int numLanes,
                        double maxSpeed, int prio,
                        SVCPermissions permissions,
                        LaneSpreadFunction spreadType,
                        double width,
                        bool oneWayIsDefault,
                        double sidewalkWidth,
                        double bikeLaneWidth,
                        double widthResolution,
                        double maxWidth,
                        double minWidth);
 
    void insertEdgeType(const std::string& id, const EdgeTypeDefinition* edgeType);
 
    void insertLaneType(const std::string& edgeTypeID,
                        int index,
                        double maxSpeed,
                        SVCPermissions permissions,
                        double width,
                        const std::set<SumoXMLAttr>& attrs);
 
    int size() const;
 
    void removeEdgeType(const std::string& id);
 
    void updateEdgeTypeID(const std::string& oldId, const std::string& newId);
 
    TypesCont::const_iterator begin() const;
 
    TypesCont::const_iterator end() const;
 
    bool knows(const std::string& edgeType) const;
 
    const EdgeTypeDefinition* getEdgeType(const std::string& name) const;
 
 
    bool markEdgeTypeAsToDiscard(const std::string& id);
 
    bool markEdgeTypeAsSet(const std::string& id, const SumoXMLAttr attr);
 
    bool addEdgeTypeRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed);
 
    bool copyEdgeTypeRestrictionsAndAttrs(const std::string& fromId, const std::string& toId);
 
    bool markLaneTypeAsSet(const std::string& id, int index, const SumoXMLAttr attr);
 
    bool addLaneTypeRestriction(const std::string& id, const SUMOVehicleClass svc, const double speed);
 
    void writeEdgeTypes(OutputDevice& into, const std::set<std::string>& typeIDs = std::set<std::string>()) const;
 
 
    int getEdgeTypeNumLanes(const std::string& edgeType) const;
 
    double getEdgeTypeSpeed(const std::string& edgeType) const;
 
    double getEdgeTypeFriction(const std::string& edgeType) const;
 
    int getEdgeTypePriority(const std::string& edgeType) const;
 
    bool getEdgeTypeIsOneWay(const std::string& edgeType) const;
 
    bool getEdgeTypeShallBeDiscarded(const std::string& edgeType) const;
 
    double getEdgeTypeWidthResolution(const std::string& edgeType) const;
 
    double getEdgeTypeMaxWidth(const std::string& edgeType) const;
 
    double getEdgeTypeMinWidth(const std::string& edgeType) const;
 
    bool wasSetEdgeTypeAttribute(const std::string& edgeType, const SumoXMLAttr attr) const;
 
    SVCPermissions getEdgeTypePermissions(const std::string& edgeType) const;
 
    LaneSpreadFunction getEdgeTypeSpreadType(const std::string& edgeType) const;
 
    double getEdgeTypeWidth(const std::string& edgeType) const;
 
    double getEdgeTypeSidewalkWidth(const std::string& edgeType) const;
 
    double getEdgeTypeBikeLaneWidth(const std::string& edgeType) const;
 
 
protected:
    EdgeTypeDefinition* myDefaultType;
 
    TypesCont myEdgeTypes;
 
private:
    NBTypeCont(const NBTypeCont& s) = delete;
 
    NBTypeCont& operator=(const NBTypeCont& s) = delete;
};