MSPerson.h

Go to the documentation of this file.

/****************************************************************************/
// The class for modelling person-movements
/****************************************************************************/
// 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 MSPerson_h
#define MSPerson_h


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

#include <string>
#include <vector>
#include <set>


// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSEdge;
class OutputDevice;

typedef std::vector<const MSEdge*> MSEdgeVector;


// ===========================================================================
// class definitions
// ===========================================================================
class MSPerson {
public:
    class MSPersonStage {
    public:
        MSPersonStage(const MSEdge &destination);

        virtual ~MSPersonStage();

        const MSEdge &getDestination() const;

        virtual void proceed(MSNet *net, MSPerson *person, SUMOTime now, const MSEdge &previousEdge) = 0;

        void setDeparted(SUMOTime now);

        void setArrived(SUMOTime now);

        virtual bool isWaitingFor(const std::string &line) const;

        virtual void tripInfoOutput(OutputDevice &os) const throw(IOError) = 0;


    protected:
        const MSEdge &myDestination;

        SUMOTime myDeparted;

        SUMOTime myArrived;

    private:
        MSPersonStage(const MSPersonStage&);

        MSPersonStage& operator=(const MSPersonStage&);

    };

    class MSPersonStage_Walking : public MSPersonStage {
    public:
        MSPersonStage_Walking(MSEdgeVector route, SUMOTime walkingTime, SUMOReal speed);

        ~MSPersonStage_Walking();

        virtual void proceed(MSNet *net, MSPerson *person, SUMOTime now, const MSEdge &previousEdge);

        virtual void tripInfoOutput(OutputDevice &os) const throw(IOError);

    private:
        SUMOTime myWalkingTime;

    private:
        MSPersonStage_Walking(const MSPersonStage_Walking&);

        MSPersonStage_Walking& operator=(const MSPersonStage_Walking&);

    };

    class MSPersonStage_Driving : public MSPersonStage {
    public:
        MSPersonStage_Driving(const MSEdge &destination,
                              const std::vector<std::string> &lines);

        ~MSPersonStage_Driving();

        virtual void proceed(MSNet *net, MSPerson *person, SUMOTime now, const MSEdge &previousEdge);

        bool isWaitingFor(const std::string &line) const;

        virtual void tripInfoOutput(OutputDevice &os) const throw(IOError);

    private:
        const std::set<std::string> myLines;

    private:
        MSPersonStage_Driving(const MSPersonStage_Driving&);

        MSPersonStage_Driving& operator=(const MSPersonStage_Driving&);

    };

    class MSPersonStage_Waiting : public MSPersonStage {
    public:
        MSPersonStage_Waiting(const MSEdge &destination, SUMOTime duration, SUMOTime until);

        ~MSPersonStage_Waiting();

        virtual void proceed(MSNet *net, MSPerson *person, SUMOTime now, const MSEdge &previousEdge);

        virtual void tripInfoOutput(OutputDevice &os) const throw(IOError);

    private:
        SUMOTime myWaitingDuration;

        SUMOTime myWaitingUntil;

    private:
        MSPersonStage_Waiting(const MSPersonStage_Waiting&);

        MSPersonStage_Waiting& operator=(const MSPersonStage_Waiting&);

    };

public:
    typedef std::vector<MSPersonStage*> MSPersonPlan;

private:
    const SUMOVehicleParameter *myParameter;

    MSPersonPlan *myPlan;

    MSPersonPlan::iterator myStep;

public:
    MSPerson(const SUMOVehicleParameter* pars, MSPersonPlan *plan);

    ~MSPerson();

    const std::string& getID() const throw();

    void proceed(MSNet *net, SUMOTime time);

    SUMOTime getDesiredDepart() const throw();

    void setDeparted(SUMOTime now);

    const MSEdge &getDestination() const;

    void tripInfoOutput(OutputDevice &os) const throw(IOError);

    bool isWaitingFor(const std::string &line) const;

private:
    MSPerson(const MSPerson&);

    MSPerson& operator=(const MSPerson&);

};


#endif

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