Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
       4             : // This program and the accompanying materials are made available under the
       5             : // terms of the Eclipse Public License 2.0 which is available at
       6             : // https://www.eclipse.org/legal/epl-2.0/
       7             : // This Source Code may also be made available under the following Secondary
       8             : // Licenses when the conditions for such availability set forth in the Eclipse
       9             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10             : // or later which is available at
      11             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13             : /****************************************************************************/
      14             : /// @file    NIXMLEdgesHandler.h
      15             : /// @author  Daniel Krajzewicz
      16             : /// @author  Jakob Erdmann
      17             : /// @author  Michael Behrisch
      18             : /// @author  Leonhard Luecken
      19             : /// @date    Tue, 20 Nov 2001
      20             : ///
      21             : // Importer for network edges stored in XML
      22             : /****************************************************************************/
      23             : #pragma once
      24             : #include <config.h>
      25             : 
      26             : #include <utils/common/SUMOVehicleClass.h>
      27             : #include <utils/geom/PositionVector.h>
      28             : #include <utils/xml/SUMOSAXHandler.h>
      29             : #include <netbuild/NBEdge.h>
      30             : #include <netbuild/NBEdgeCont.h>
      31             : 
      32             : 
      33             : // ===========================================================================
      34             : // class declarations
      35             : // ===========================================================================
      36             : class OptionsCont;
      37             : class NBNode;
      38             : class NBEdge;
      39             : class NBNodeCont;
      40             : class NBTypeCont;
      41             : class NBDistrictCont;
      42             : class NBTrafficLightLogicCont;
      43             : 
      44             : // ===========================================================================
      45             : // class definitions
      46             : // ===========================================================================
      47             : /**
      48             :  * @class NIXMLEdgesHandler
      49             :  * @brief Importer for network edges stored in XML
      50             :  *
      51             :  * This SAX-handler parses edge information and stores it in the given
      52             :  *  container.
      53             :  * @todo revalidate node retrieval
      54             :  * @todo One day, one should rethink the order of parsing. Now, the handler
      55             :  *  is able to load edges, using information from the types, first, and extending
      56             :  *  them by given information. In addition, if the read edge is already known,
      57             :  *  its values are also used. Then, defining vehicles allowed per lane, and
      58             :  *  additional edge split definitions add some further complexity. This all
      59             :  *  works somehow for most of our use cases, but it's definitely not as consistent
      60             :  *  that everything what seems to be possible would also work appropriately.
      61             :  */
      62             : class NIXMLEdgesHandler : public SUMOSAXHandler {
      63             : public:
      64             :     /** @brief Constructor
      65             :      * @param[in] nc The nodes container (for retrieval of referenced nodes)
      66             :      * @param[in] ec The edges container (for insertion of build edges)
      67             :      * @param[in] tc The types container (for retrieval of type defaults)
      68             :      * @param[in] dc The districts container (needed if an edge must be split)
      69             :      * @param[in] options The options to use while building edges
      70             :      */
      71             :     NIXMLEdgesHandler(NBNodeCont& nc, NBEdgeCont& ec,
      72             :                       NBTypeCont& tc, NBDistrictCont& dc,
      73             :                       NBTrafficLightLogicCont& tlc,
      74             :                       OptionsCont& options);
      75             : 
      76             : 
      77             :     /// @brief Destructor
      78             :     ~NIXMLEdgesHandler();
      79             : 
      80             : protected:
      81             :     /// @name inherited from GenericSAXHandler
      82             :     //@{
      83             : 
      84             :     /** @brief Called on the opening of a tag;
      85             :      *
      86             :      * @param[in] element ID of the currently opened element
      87             :      * @param[in] attrs Attributes within the currently opened element
      88             :      * @exception ProcessError If something fails
      89             :      * @see GenericSAXHandler::myStartElement
      90             :      */
      91             :     void myStartElement(int element,
      92             :                         const SUMOSAXAttributes& attrs);
      93             : 
      94             : 
      95             :     /** @brief Called when a closing tag occurs
      96             :      *
      97             :      * @param[in] element ID of the currently opened element
      98             :      * @exception ProcessError If something fails
      99             :      * @see GenericSAXHandler::myEndElement
     100             :      */
     101             :     void myEndElement(int element);
     102             :     //@}
     103             : 
     104             : 
     105             : private:
     106             :     /** @brief Tries to parse the shape definition
     107             :      *
     108             :      * Returns the edge's geometry (may be empty if no one was defined).
     109             :      * Writes an error message if an error occurred.
     110             :      * @param[in] attrs The attributes to read the shape from
     111             :      * @return The edge's shape
     112             :      */
     113             :     PositionVector tryGetShape(const SUMOSAXAttributes& attrs);
     114             : 
     115             : 
     116             :     /** @brief Tries to parse the spread type
     117             :      */
     118             :     LaneSpreadFunction tryGetLaneSpread(const SUMOSAXAttributes& attrs);
     119             : 
     120             : 
     121             :     /** @brief Sets from/to node information of the currently parsed edge
     122             :      *
     123             :      * If the nodes could be retrieved/built, they are set in myFromNode/myToNode,
     124             :      *  respectively, and true is returned. If not, false is returned.
     125             :      * @param[in] attrs The SAX-attributes to parse the nodes from
     126             :      * @return Whether valid nodes exist
     127             :      */
     128             :     bool setNodes(const SUMOSAXAttributes& attrs);
     129             : 
     130             : 
     131             : private:
     132             :     /// @brief A reference to the program's options
     133             :     OptionsCont& myOptions;
     134             : 
     135             : 
     136             :     /// @name Currently parsed edge's values
     137             :     /// @{
     138             : 
     139             :     /// @brief The current edge's id
     140             :     std::string myCurrentID;
     141             : 
     142             :     /// @brief The current edge's maximum speed
     143             :     double myCurrentSpeed;
     144             : 
     145             :     /// @brief The current edge's friction
     146             :     double myCurrentFriction;
     147             : 
     148             :     /// @brief The current edge's priority
     149             :     int myCurrentPriority;
     150             : 
     151             :     /// @brief The current edge's number of lanes
     152             :     int myCurrentLaneNo;
     153             : 
     154             :     /// @brief The current edge's lane width
     155             :     double myCurrentWidth;
     156             : 
     157             :     /// @brief The current edge's offset till the destination node
     158             :     double myCurrentEndOffset;
     159             : 
     160             :     /// @brief The current edge's street name
     161             :     std::string myCurrentStreetName;
     162             : 
     163             :     /// @brief The current edge's type
     164             :     std::string myCurrentType;
     165             : 
     166             :     /// @brief The nodes the edge starts and ends at
     167             :     NBNode* myFromNode, *myToNode;
     168             : 
     169             :     /// @brief The current edge's length
     170             :     double myLength;
     171             : 
     172             :     /// @brief The shape of the edge
     173             :     PositionVector myShape;
     174             : 
     175             :     /// @brief Information about how to spread the lanes
     176             :     LaneSpreadFunction myLanesSpread;
     177             : 
     178             :     /// @brief Information about lane permissions
     179             :     SVCPermissions myPermissions;
     180             : 
     181             :     /// @brief Whether the edge shape shall be kept at reinitilization
     182             :     bool myReinitKeepEdgeShape;
     183             : 
     184             :     /// @brief The width of the sidewalk that shall be added to the current edge
     185             :     double mySidewalkWidth;
     186             : 
     187             :     /// @brief The width of the bike lane that shall be added to the current edge
     188             :     double myBikeLaneWidth;
     189             : 
     190             :     /// @}
     191             : 
     192             : 
     193             :     /// @brief Whether this edge definition is an update of a previously inserted edge
     194             :     bool myIsUpdate;
     195             : 
     196             : 
     197             :     /// @name Used instance containers (access to nodes, edges, types, etc.)
     198             :     /// @{
     199             : 
     200             :     /// @brief The nodes container (for retrieval of referenced nodes)
     201             :     NBNodeCont& myNodeCont;
     202             : 
     203             :     /// @brief The edges container (for insertion of build edges)
     204             :     NBEdgeCont& myEdgeCont;
     205             : 
     206             :     /// @brief The types container (for retrieval of type defaults)
     207             :     NBTypeCont& myTypeCont;
     208             : 
     209             :     /// @brief The districts container (needed if an edge must be split)
     210             :     NBDistrictCont& myDistrictCont;
     211             : 
     212             :     /** @brief The traffic lights container to add built tls to (when
     213             :      * invalidating tls because of splits) */
     214             :     NBTrafficLightLogicCont& myTLLogicCont;
     215             :     /// @}
     216             : 
     217             : 
     218             :     /// @brief The currently processed edge
     219             :     NBEdge* myCurrentEdge;
     220             : 
     221             :     /// @brief The currently processed lane index
     222             :     int myCurrentLaneIndex;
     223             : 
     224             :     /// @brief The list of this edge's splits
     225             :     std::vector<NBEdgeCont::Split> mySplits;
     226             : 
     227             :     /** @class split_by_pos_finder
     228             :      * @brief Finds a split at the given position
     229             :      */
     230             :     class split_by_pos_finder {
     231             :     public:
     232             :         /// @brief Constructor
     233             :         explicit split_by_pos_finder(double pos)
     234         245 :             : myPosition(pos) { }
     235             : 
     236             :         /// @brief Comparing operator
     237             :         bool operator()(const NBEdgeCont::Split& e) {
     238         115 :             return e.pos == myPosition;
     239             :         }
     240             : 
     241             :     private:
     242             :         /// @brief The position to search for
     243             :         double myPosition;
     244             : 
     245             :     };
     246             : 
     247             : 
     248             :     /// @brief Information whether at least one edge's attributes were overwritten
     249             :     bool myHaveReportedAboutOverwriting;
     250             : 
     251             :     /// @brief Information whether at least one edge's type was changed
     252             :     bool myHaveReportedAboutTypeOverride;
     253             : 
     254             :     bool myHaveWarnedAboutDeprecatedLaneId;
     255             : 
     256             :     /// @brief Whether the edge shape shall be kept generally
     257             :     const bool myKeepEdgeShape;
     258             : 
     259             :     /// @brief element to receive parameters
     260             :     std::vector<Parameterised*> myLastParameterised;
     261             : 
     262             :     /// @brief The coordinate transformation which was used compute the node coordinates
     263             :     GeoConvHelper* myLocation = nullptr;
     264             : 
     265             : private:
     266             : 
     267             :     /** @brief Parses an edge and stores the values in "myCurrentEdge"
     268             :      * @param[in] attrs The attributes to get the edge's values from
     269             :      */
     270             :     void addEdge(const SUMOSAXAttributes& attrs);
     271             : 
     272             :     /** @brief parses delete tag and deletes the specified edge or lane
     273             :      * @param[in] attrs The attributes to get the edge id and the optional lane index from
     274             :      */
     275             :     void deleteEdge(const SUMOSAXAttributes& attrs);
     276             : 
     277             :     /** @brief Parses a lane and modifies myCurrentEdge according to the given
     278             :      * attribures
     279             :      * @param[in] attrs The attributes to get the lanes's values from
     280             :      */
     281             :     void addLane(const SUMOSAXAttributes& attrs);
     282             : 
     283             :     /** @brief Parses a split and stores it in mySplits. Splits are executed Upon reading the end
     284             :      * tag of an edge
     285             :      * @param[in] attrs The attributes to get the splits's values from
     286             :      */
     287             :     void addSplit(const SUMOSAXAttributes& attrs);
     288             : 
     289             :     /** @brief Parses a roundabout and stores it in myEdgeCont.
     290             :      * @param[in] attrs The attributes to get the roundabouts values from
     291             :      */
     292             :     void addRoundabout(const SUMOSAXAttributes& attrs);
     293             : 
     294             : 
     295             : private:
     296             :     /** @brief invalid copy constructor */
     297             :     NIXMLEdgesHandler(const NIXMLEdgesHandler& s);
     298             : 
     299             :     /** @brief invalid assignment operator */
     300             :     NIXMLEdgesHandler& operator=(const NIXMLEdgesHandler& s);
     301             : 
     302             : };