NIImporter_DlrNavteq.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2008-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
/****************************************************************************/
// Importer for networks stored in Elmar's format
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <utils/common/UtilExceptions.h>
#include <utils/importio/LineHandler.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NBEdgeCont;
class NBNetBuilder;
class NBNodeCont;
class NBTrafficLightLogicCont;
class NBTypeCont;
class OptionsCont;
class PositionVector;
class StringTokenizer;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NIImporter_DlrNavteq {
public:
    static void loadNetwork(const OptionsCont& oc, NBNetBuilder& nb);
 
    static const std::string GEO_SCALE;
 
    static bool keepLength;
 
    static const std::string UNDEFINED;
 
protected:
    class NodesHandler : public LineHandler {
    public:
        NodesHandler(NBNodeCont& nc, const std::string& file,
                     std::map<std::string, PositionVector>& geoms);
 
 
        ~NodesHandler();
 
 
        bool report(const std::string& result);
 
 
    protected:
        // @brief The node container to store parsed nodes into
        NBNodeCont& myNodeCont;
 
        std::map<std::string, PositionVector>& myGeoms;
 
 
    private:
        NodesHandler(const NodesHandler&);
 
        NodesHandler& operator=(const NodesHandler&);
 
    };
 
 
    class EdgesHandler : public LineHandler {
 
    public:
        EdgesHandler(NBNodeCont& nc, NBEdgeCont& ec, NBTypeCont& tc,
                     const std::string& file,
                     std::map<std::string, PositionVector>& geoms,
                     std::map<std::string, std::string>& streetNames);
 
 
        ~EdgesHandler();
 
 
        bool report(const std::string& result);
 
 
    protected:
        NBNodeCont& myNodeCont;
 
        NBEdgeCont& myEdgeCont;
 
        NBTypeCont& myTypeCont;
 
        std::map<std::string, PositionVector>& myGeoms;
 
        std::map<std::string, std::string>& myStreetNames;
 
        bool myTryIgnoreNodePositions;
 
        double myVersion;
 
        std::vector<int> myColumns;
 
        const std::string myFile;
 
        static const int MISSING_COLUMN;
 
        enum ColumnName {
            LINK_ID = 0,
            NODE_ID_FROM,
            NODE_ID_TO,
            BETWEEN_NODE_ID,
            LENGTH,
            VEHICLE_TYPE,
            FORM_OF_WAY,
            BRUNNEL_TYPE,
            FUNCTIONAL_ROAD_CLASS,
            SPEED_CATEGORY,
            NUMBER_OF_LANES,
            SPEED_LIMIT,
            SPEED_RESTRICTION,
            NAME_ID1_REGIONAL,
            NAME_ID2_LOCAL,
            HOUSENUMBERS_RIGHT,
            HOUSENUMBERS_LEFT,
            ZIP_CODE,
            AREA_ID,
            SUBAREA_ID,
            THROUGH_TRAFFIC,
            SPECIAL_RESTRICTIONS,
            EXTENDED_NUMBER_OF_LANES,
            ISRAMP,
            CONNECTION
        };
 
        std::string getColumn(const StringTokenizer& st, ColumnName name, const std::string fallback = "");
 
    private:
        std::string getStreetNameFromIDs(const std::string& regionalID, const std::string& localID) const;
 
 
    private:
        EdgesHandler(const EdgesHandler&);
 
        EdgesHandler& operator=(const EdgesHandler&);
 
    };
 
 
    class TrafficlightsHandler : public LineHandler {
    public:
        TrafficlightsHandler(NBNodeCont& nc, NBTrafficLightLogicCont& tlc,
                             NBEdgeCont& ne, const std::string& file);
 
 
        ~TrafficlightsHandler();
 
 
        bool report(const std::string& result);
 
 
    protected:
        NBNodeCont& myNodeCont;
 
        NBTrafficLightLogicCont& myTLLogicCont;
 
        NBEdgeCont& myEdgeCont;
 
 
    private:
        TrafficlightsHandler(const TrafficlightsHandler&);
 
        TrafficlightsHandler& operator=(const TrafficlightsHandler&);
 
    };
 
 
    class NamesHandler : public LineHandler {
    public:
        NamesHandler(const std::string& file, std::map<std::string, std::string>& streetNames);
 
 
        ~NamesHandler();
 
 
        bool report(const std::string& result);
 
 
    protected:
        std::map<std::string, std::string>& myStreetNames;
 
 
    private:
        NamesHandler(const NamesHandler&);
 
        NamesHandler& operator=(const NamesHandler&);
 
    };
 
 
    class TimeRestrictionsHandler : public LineHandler {
    public:
        TimeRestrictionsHandler(NBEdgeCont& ec, NBDistrictCont& dc, time_t constructionTime);
 
 
        ~TimeRestrictionsHandler();
 
 
        bool report(const std::string& result);
 
        void printSummary();
 
 
    protected:
        NBEdgeCont& myEdgeCont;
        NBDistrictCont& myDistrictCont;
 
        time_t myConstructionTime;
        time_t myCS_min;
        time_t myCS_max;
        int myConstructionEntries;
        int myNotStarted;
        int myUnderConstruction;
        int myFinished;
        int myRemovedEdges; // only counts those not already removed through other options
 
 
    private:
        TimeRestrictionsHandler(const TimeRestrictionsHandler&);
 
        TimeRestrictionsHandler& operator=(const TimeRestrictionsHandler&);
 
    };
 
 
    class ProhibitionHandler : public LineHandler {
    public:
        ProhibitionHandler(NBEdgeCont& ne, const std::string& file, time_t constructionTime);
 
 
        ~ProhibitionHandler();
 
 
        bool report(const std::string& result);
 
 
    protected:
        NBEdgeCont& myEdgeCont;
        const std::string myFile;
        double myVersion;
        time_t myConstructionTime;
 
 
    private:
        ProhibitionHandler(const ProhibitionHandler&);
 
        ProhibitionHandler& operator=(const ProhibitionHandler&);
 
    };
 
 
    class ConnectedLanesHandler : public LineHandler {
    public:
        ConnectedLanesHandler(NBEdgeCont& ne);
 
 
        ~ConnectedLanesHandler();
 
 
        bool report(const std::string& result);
 
 
    protected:
        NBEdgeCont& myEdgeCont;
 
 
    private:
        ConnectedLanesHandler(const ConnectedLanesHandler&);
 
        ConnectedLanesHandler& operator=(const ConnectedLanesHandler&);
 
    };
 
 
    static double readVersion(const std::string& line, const std::string& file);
    static int readPrefixedInt(const std::string& s, const std::string& prefix, int fallBack = 0);
    static time_t readTimeRec(const std::string& start, const std::string& duration);
    static time_t readDate(const std::string& yyyymmdd);
 
};