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 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 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 <utils/common/SUMOTime.h>
#include <utils/common/RandomDistributor.h>
#include <utils/common/SUMOVehicleParameter.h>


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


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

public:
    MSVehicleControl() throw();


    virtual ~MSVehicleControl() throw();



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




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


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


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


    void scheduleVehicleRemoval(MSVehicle *v) throw();


    constVehIt loadedVehBegin() const throw();


    constVehIt loadedVehEnd() const throw();




    virtual void vehicleEmitted(const MSVehicle &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 getEmittedVehicleNo() const throw() {
        return myRunningVehNo + myEndedVehNo;
    }


    bool haveAllVehiclesQuit() const throw() {
        return myLoadedVehNo==myEndedVehNo;
    }




    SUMOReal getMeanWaitingTime() const throw();


    SUMOReal getMeanTravelTime() 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, MSVehicle *vehicle) throw();

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

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


#ifdef HAVE_MESOSIM


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

    void loadState(BinaryInputDevice &bis) throw();
#endif


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


protected:

    unsigned int myLoadedVehNo;

    unsigned int myRunningVehNo;

    unsigned int myEndedVehNo;



    SUMOTime myAbsVehWaitingTime;

    SUMOTime myAbsVehTravelTime;



    typedef std::map< std::string, MSVehicle* > 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<MSVehicle*> > myWaiting;


private:
    MSVehicleControl(const MSVehicleControl &s);

    MSVehicleControl &operator=(const MSVehicleControl &s);


};


#endif

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