FlippedEdge.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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
/****************************************************************************/
// Extension of ReversedEdge, which is a wrapper around a ROEdge
// or an MSEdge used for backward search. In contrast to reversed
// edges, flipped edges have flipped nodes instead of standard nodes.
// Introduced for the arc flag router.
/****************************************************************************/
#pragma once
#include <config.h>
#include <utils/common/SUMOVehicleClass.h>
#ifdef HAVE_FOX
#include <utils/foxtools/MsgHandlerSynchronized.h>
#endif
#include "ReversedEdge.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
template<class E, class N, class V>
class FlippedNode;
 
// ===========================================================================
// class definitions
// ===========================================================================
template<class E, class N, class V>
class FlippedEdge : public ReversedEdge<E, V> {
public:
 
    typedef std::vector<std::pair<const FlippedEdge<E, N, V>*, const FlippedEdge<E, N, V>*> > ConstFlippedEdgePairVector;
 
    FlippedEdge(const E* originalEdge) :
        ReversedEdge<E, V>(originalEdge),
        myFromJunction(originalEdge->getToJunction()->getFlippedRoutingNode()),
        myToJunction(originalEdge->getFromJunction()->getFlippedRoutingNode())
    {}
    FlippedEdge(const E* originalEdge) : {…}
 
    ~FlippedEdge() {}
 
    void init();
 
    const FlippedNode<E, N, V>* getFromJunction() const {
        return myFromJunction;
    }
    const FlippedNode<E, N, V>* getFromJunction() const  {…}
 
    const FlippedNode<E, N, V>* getToJunction() const {
        return myToJunction;
    }
    const FlippedNode<E, N, V>* getToJunction() const  {…}
 
    static double getTravelTimeStatic(const FlippedEdge<E, N, V>* const edge, const V* const veh, double time) {
        return edge->getOriginalEdge()->getTravelTime(veh, time);
    }
    static double getTravelTimeStatic(const FlippedEdge<E, N, V>* const edge, const V* const veh, double time) {…}
 
    static double getTravelTimeStaticRandomized(const FlippedEdge<E, N, V>* const edge, const V* const veh, double time) {
        return edge->getOriginalEdge()->getTravelTimeStaticRandomized(edge->getOriginalEdge(), veh, time);
    }
    static double getTravelTimeStaticRandomized(const FlippedEdge<E, N, V>* const edge, const V* const veh, double time) {…}
 
    const ConstFlippedEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const {
        UNUSED_PARAMETER(ignoreTransientPermissions); // @todo this should be changed (somewhat hidden by #14756)
        if (vClass == SVC_IGNORING || this->getOriginalEdge()->isTazConnector()) { // || !MSNet::getInstance()->hasPermissions()) {
            return myViaSuccessors;
        }
#ifdef HAVE_FOX
        FXMutexLock lock(mySuccessorMutex);
#endif
        auto i = myClassesViaSuccessorMap.find(vClass);
        if (i != myClassesViaSuccessorMap.end()) {
            // can use cached value
            return i->second;
        }
        // instantiate vector
        ConstFlippedEdgePairVector& result = myClassesViaSuccessorMap[vClass];
        // this vClass is requested for the first time. rebuild all successors
        for (const auto& viaPair : myViaSuccessors) {
            if (viaPair.first->getOriginalEdge()->isTazConnector()
                    || viaPair.first->getOriginalEdge()->isConnectedTo(*(this->getOriginalEdge()), vClass)) {
                result.push_back(viaPair);
            }
        }
        return result;
    }
    const ConstFlippedEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const  {…}
 
    const FlippedEdge<E, N, V>* getBidiEdge() const {
        return this->getOriginalEdge()->getBidiEdge()->getFlippedRoutingEdge();
    }
    const FlippedEdge<E, N, V>* getBidiEdge() const  {…}
 
    double getDistanceTo(const FlippedEdge<E, N, V>* other, const bool doBoundaryEstimate = false) const {
        return this->getOriginalEdge()->getDistanceTo(other->getOriginalEdge(), doBoundaryEstimate);
    }
    double getDistanceTo(const FlippedEdge<E, N, V>* other, const bool doBoundaryEstimate = false) const  {…}
 
    double getMinimumTravelTime(const V* const veh) const {
        return this->getOriginalEdge()->getMinimumTravelTime(veh);
    }
    double getMinimumTravelTime(const V* const veh) const  {…}
 
    double getTimePenalty() const {
        return this->getOriginalEdge()->getTimePenalty();
    }
    double getTimePenalty() const  {…}
 
    bool hasLoadedTravelTimes() const {
        return this->getOriginalEdge()->hasLoadedTravelTimes();
    }
    bool hasLoadedTravelTimes() const  {…}
 
    double getSpeedLimit() const {
        return this->getOriginalEdge()->getSpeedLimit();
    }
    double getSpeedLimit() const  {…}
 
    double getLengthGeometryFactor() const {
        return this->getOriginalEdge()->getLengthGeometryFactor();
    }
    double getLengthGeometryFactor() const  {…}
 
    int getPriority() const {
        return this->getOriginalEdge()->getPriority();
    }
    int getPriority() const  {…}
 
protected:
    FlippedNode<E, N, V>* myFromJunction;
    FlippedNode<E, N, V>* myToJunction;
 
private:
    mutable std::map<SUMOVehicleClass, ConstFlippedEdgePairVector> myClassesViaSuccessorMap;
    mutable ConstFlippedEdgePairVector myViaSuccessors;
 
#ifdef HAVE_FOX
    mutable FXMutex mySuccessorMutex;
#endif
};
 
// ===========================================================================
// method definitions
// ===========================================================================
 
template<class E, class N, class V>
void FlippedEdge<E, N, V>::init() {
    if (!this->getOriginalEdge()->isInternal()) {
        for (const auto& viaPair : this->getOriginalEdge()->getViaSuccessors()) {
            const FlippedEdge<E, N, V>* revSource = viaPair.first->getFlippedRoutingEdge();
            const E* via = viaPair.second;
            const FlippedEdge<E, N, V>* preVia = nullptr;
            while (via != nullptr && via->isInternal()) {
                via->getFlippedRoutingEdge()->myViaSuccessors.push_back(std::make_pair(this, preVia));
                preVia = via->getFlippedRoutingEdge();
                via = via->getViaSuccessors().front().second;
            }
            revSource->myViaSuccessors.push_back(std::make_pair(this, preVia));
        }
    }
}
void FlippedEdge<E, N, V>::init() {…}
    void init(); {…}
class FlippedEdge : public ReversedEdge<E, V> {…};