NBPTStop.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
/****************************************************************************/
// The representation of a single pt stop
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <memory>
#include <string>
#include <utils/common/Parameterised.h>
#include <utils/geom/Position.h>
#include "NBPTPlatform.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class NBEdgeCont;
class NBEdge;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBPTStop : public Parameterised {
 
public:
    NBPTStop(std::string ptStopId, Position position, std::string edgeId, std::string origEdgeId, double length, std::string name,
             SVCPermissions svcPermissions, double parkingLength = 0, const RGBColor color = RGBColor(false), double  givenStartPos = -1);
 
    virtual ~NBPTStop() {};
 
    std::string getID() const;
 
    const std::string& getEdgeId() const;
 
    const std::string& getLaneId() const {
        return myLaneId;
    }
 
    const std::string getOrigEdgeId() const;
 
    const std::string getName() const;
 
    const Position& getPosition() const;
 
    SVCPermissions getPermissions() const;
 
    long long int getAreaID() const {
        return myAreaID;
    }
 
    void write(OutputDevice& device);
 
    void reshiftPosition(const double offsetX, const double offsetY);
 
    const std::vector<NBPTPlatform>& getPlatformCands();
 
    bool getIsMultipleStopPositions() const;
 
    void setIsMultipleStopPositions(bool multipleStopPositions, long long int areaID);
 
    double getLength() const;
 
    bool setEdgeId(std::string edgeId, const NBEdgeCont& ec);
 
    void registerAdditionalEdge(std::string wayId, std::string edgeId);
 
    void addPlatformCand(NBPTPlatform platform);
 
    bool findLaneAndComputeBusStopExtent(const NBEdgeCont& ec);
 
    bool findLaneAndComputeBusStopExtent(const NBEdge* edge);
 
    void setPTStopId(std::string id) {
        myPTStopId = id;
    }
 
    void setIsPlatform() {
        myIsPlatform = true;
    }
 
    bool isPlatform() const {
        return myIsPlatform;
    }
    void addAccess(std::string laneID, double offset, double length);
 
    void clearAccess();
 
    void addLine(const std::string& line);
 
    void setBidiStop(std::shared_ptr<NBPTStop> bidiStop) {
        myBidiStop = bidiStop;
    }
 
    std::shared_ptr<NBPTStop> getBidiStop() const {
        return myBidiStop.lock();
    }
 
    bool isLoose() const {
        return myIsLoose;
    }
 
    double getEndPos() const {
        return myEndPos;
    }
 
    const std::vector<std::string>& getLines() const {
        return myLines;
    }
 
    void mirrorX();
 
    bool replaceEdge(const std::string& edgeID, const std::vector<NBEdge*>& replacement);
 
    const std::map<std::string, std::string>& getAdditionalEdgeCandidates() const {
        return myAdditionalEdgeCandidates;
    }
    void setOrigEdgeId(const std::string& origEdgeId) {
        myOrigEdgeId = origEdgeId;
    }
    void setPTStopLength(double ptStopLength) {
        myPTStopLength = ptStopLength;
    }
 
private:
    std::string myPTStopId;
    Position myPosition;
    std::string myEdgeId;
    std::map<std::string, std::string> myAdditionalEdgeCandidates;
    std::string myOrigEdgeId;
    double myPTStopLength;
    const std::string myName;
    const double myParkingLength;
    const RGBColor myColor;
    std::string myLaneId;
    const SVCPermissions myPermissions;
 
    double myStartPos;
    double myEndPos;
 
    std::vector<std::tuple<std::string, double, double>> myAccesses;
 
    std::vector<std::string> myLines;
 
    std::weak_ptr<NBPTStop> myBidiStop;
 
    bool myIsLoose;
 
    bool myIsPlatform;
 
    std::vector<NBPTPlatform> myPlatformCands;
    bool myIsMultipleStopPositions;
    long long int myAreaID;
    double myGivenStartPos;
 
private:
    NBPTStop& operator=(const NBPTStop&);
 
};