SUMOAbstractRouter.h

Go to the documentation of this file.

/****************************************************************************/
// The dijkstra-router
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2012 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef SUMOAbstractRouter_h
#define SUMOAbstractRouter_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <vector>
#include <algorithm>
#include <utils/common/SUMOTime.h>


// ===========================================================================
// class definitions
// ===========================================================================
template<class E, class V>
class SUMOAbstractRouter {
public:
    class ROAbstractEdgeEffortRetriever {
    public:
        ROAbstractEdgeEffortRetriever() { }

        virtual ~ROAbstractEdgeEffortRetriever() { }

        virtual SUMOReal getEffort(const V* const, SUMOTime time, const E* const edge,
                                   SUMOReal dist) const = 0;

        virtual const std::string& getID() const = 0;

    };


public:
    SUMOAbstractRouter() { }

    virtual ~SUMOAbstractRouter() { }

    virtual void compute(const E* from, const E* to, const V* const vehicle,
                         SUMOTime msTime, std::vector<const E*> &into) = 0;

    virtual SUMOReal recomputeCosts(const std::vector<const E*> &edges,
                                    const V* const v, SUMOTime msTime) const = 0;

};


template<class E, class V>
struct prohibited_withRestrictions {
public:
    inline bool operator()(const E* edge, const V* vehicle) const {
        if (std::find(myProhibited.begin(), myProhibited.end(), edge) != myProhibited.end()) {
            return true;
        }
        return edge->prohibits(vehicle);
    }

    void prohibit(const std::vector<E*> &toProhibit) {
        myProhibited = toProhibit;
    }

protected:
    std::vector<E*> myProhibited;

};

template<class E, class V>
struct prohibited_noRestrictions {
public:
    inline bool operator()(const E*, const V*) const {
        return false;
    }
};




#endif

/****************************************************************************/