SUMOAbstractRouter.h

Go to the documentation of this file.

/****************************************************************************/
// The dijkstra-router
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 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) = 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 time, std::vector<const E*> &into) = 0;

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

};


template<class E, class V>
struct prohibited_withRestrictions {
public:
    inline bool operator()(const E *edge, const V *vehicle) {
        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 *) {
        return false;
    }
};




#endif

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