AFInfo.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2012-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
/****************************************************************************/
// Definitions of informations associated with an edge for use in the arc flag
// routing algorithm (Hilger et al.). In more detail, these informations are:
// flag information for arc flag routing, a key for sorting the heap, a flag
// indicating whether the edge has already been touched, labels for holding
// (tentative / final) distances to the boundary nodes
/****************************************************************************/
#pragma once
#include <config.h>
#include <unordered_set>
 
template<class E>
class AFInfo {
public:
    class FlagInfo {
    public:
        FlagInfo(const E* const e) :
            edge(e) {
        }
        FlagInfo& operator=(const FlagInfo& other) {
            // guard self assignment
            if (this == &other) {
                return *this;
            }
            edge = other.edge;
            arcFlags = other.arcFlags;
            return *this;
        }
        virtual ~FlagInfo() {}
        virtual void reset() {
            arcFlags.clear();
        }
        const E* const edge;
        std::vector<bool> arcFlags;
    }; // end of class FlagInfo declaration
 
    class ArcInfoBase : public FlagInfo {
    public:
        ArcInfoBase(const E* const e) :
            FlagInfo(e),
            key(std::numeric_limits<double>::max()),
            touched(false) {
        }
        ArcInfoBase& operator=(const ArcInfoBase& other) {
            // guard self assignment
            if (this == &other) {
                return *this;
            }
            static_cast<FlagInfo>(this) = static_cast<FlagInfo>(other);
            key = other.key;
            touched = other.touched;
            return *this;
        }
        ~ArcInfoBase() {}
        void reset() {
            // do nothing
        }
        std::vector<bool> arcFlags;
        double key;
        bool touched;
    }; // end of class ArcInfoBase declaration
 
    class ArcInfo : public ArcInfoBase {
    public:
        ArcInfo(const E* const e) :
            ArcInfoBase(e) {
        }
        ArcInfo& operator=(const ArcInfo& other) {
            // guard self assignment
            if (this == &other) {
                return *this;
            }
            static_cast<ArcInfoBase>(this) = static_cast<ArcInfoBase>(other);
            effortsToBoundaryNodes = other.effortsToBoundaryNodes;
            return *this;
        }
        ~ArcInfo() {}
        void reset() {
            // do nothing
        }
        std::vector<double> effortsToBoundaryNodes;
    }; // end of class ArcInfo declaration
};