MSVehicleControl.h

Go to the documentation of this file.

/****************************************************************************/
// The class responsible for building and deletion of vehicles
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 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 MSVehicleControl_h
#define MSVehicleControl_h


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

#include <string>
#include <map>
#include <set>
#include "MSGlobals.h"
#include <utils/common/SUMOTime.h>
#include <utils/common/RandomDistributor.h>
#include <utils/common/SUMOVehicleParameter.h>


// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class MSVehicle;
class MSRoute;
class MSVehicleType;
class BinaryInputDevice;
class MSEdge;


// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicleControl {
public:
    typedef std::map<std::string, SUMOVehicle*>::const_iterator constVehIt;

public:
    MSVehicleControl() throw();


    virtual ~MSVehicleControl() throw();



    virtual SUMOVehicle* buildVehicle(SUMOVehicleParameter* defs, const MSRoute* route,
                                      const MSVehicleType* type) throw(ProcessError);




    virtual bool addVehicle(const std::string& id, SUMOVehicle* v) throw();


    SUMOVehicle* getVehicle(const std::string& id) const throw();


    virtual void deleteVehicle(SUMOVehicle* v) throw();


    void scheduleVehicleRemoval(SUMOVehicle* veh) throw();


    constVehIt loadedVehBegin() const throw();


    constVehIt loadedVehEnd() const throw();




    void vehicleDeparted(const SUMOVehicle& v) throw();




    unsigned int getLoadedVehicleNo() const throw() {
        return myLoadedVehNo;
    }


    unsigned int getEndedVehicleNo() const throw() {
        return myEndedVehNo;
    }


    unsigned int getRunningVehicleNo() const throw() {
        return myRunningVehNo;
    }


    unsigned int getDepartedVehicleNo() const throw() {
        return myRunningVehNo + myEndedVehNo;
    }


    bool isInQuota(const SUMOReal frac) const throw() {
        if (MSGlobals::gFractions.find(frac) == MSGlobals::gFractions.end()) {
            return (myLoadedVehNo-1) % 1000 < (unsigned int)(frac*1000.);
        }
        return (myLoadedVehNo-1) % MSGlobals::gFractions[frac].second < MSGlobals::gFractions[frac].first;
    }


    int getActiveVehicleCount() const throw() {
        return myLoadedVehNo - (myWaitingForPerson + myEndedVehNo);
    }



    void printMeanWaitingTime(OutputDevice& od) const throw();


    void printMeanTravelTime(OutputDevice& od) const throw();





    bool addVType(MSVehicleType* vehType) throw();


    bool addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*> *vehTypeDistribution) throw();


    bool hasVTypeDistribution(const std::string& id) const throw();


    MSVehicleType* getVType(const std::string& id=DEFAULT_VTYPE_ID) throw();


    void insertVTypeIDs(std::vector<std::string> &into) const throw();

    void addWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) throw();

    void removeWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) throw();

    SUMOVehicle* getWaitingVehicle(const MSEdge* const edge, const std::set<std::string> &lines) throw();

    void registerOneWaitingForPerson() {
        myWaitingForPerson++;
    }

    void unregisterOneWaitingForPerson() {
        myWaitingForPerson--;
    }


    virtual void saveState(std::ostream& os) throw();

    virtual void loadState(BinaryInputDevice& bis, const SUMOTime offset) throw();
    //

    void abortWaiting() throw();


private:
    bool checkVType(const std::string& id) throw();


protected:

    unsigned int myLoadedVehNo;

    unsigned int myRunningVehNo;

    unsigned int myEndedVehNo;



    SUMOReal myTotalDepartureDelay;

    SUMOReal myTotalTravelTime;



    typedef std::map< std::string, SUMOVehicle* > VehicleDictType;
    VehicleDictType myVehicleDict;



    typedef std::map< std::string, MSVehicleType* > VTypeDictType;
    VTypeDictType myVTypeDict;

    typedef std::map< std::string, RandomDistributor<MSVehicleType*>* > VTypeDistDictType;
    VTypeDistDictType myVTypeDistDict;

    bool myDefaultVTypeMayBeDeleted;

    std::map<const MSEdge* const, std::vector<SUMOVehicle*> > myWaiting;

    unsigned int myWaitingForPerson;


private:
    MSVehicleControl(const MSVehicleControl& s);

    MSVehicleControl& operator=(const MSVehicleControl& s);


};


#endif

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