traci::TraCIServer Class Reference

#include <TraCIServer.h>

Inheritance diagram for traci::TraCIServer:

---

Detailed Description

Definition at line 69 of file TraCIServer.h.

Public Member Functions
void	vehicleStateChanged (const MSVehicle *const vehicle, MSNet::VehicleState to) throw ()
	Called if a vehicle changes its state.
Static Public Member Functions
static void	close ()
static void	processCommandsUntilSimStep (SUMOTime step) throw (ProcessError)
static bool	wasClosed ()
Private Member Functions
bool	addSubscription (int commandId) throw (TraCIException)
bool	commandAddVehicle () throw (TraCIException)
bool	commandChangeLane () throw (TraCIException, std::invalid_argument)
bool	commandChangeRoute () throw (TraCIException, std::invalid_argument)
bool	commandChangeTarget () throw (TraCIException, std::invalid_argument)
bool	commandCloseConnection () throw (TraCIException)
bool	commandDistanceRequest () throw (TraCIException)
bool	commandGetAllTLIds () throw (TraCIException)
bool	commandGetTLStatus () throw (TraCIException)
bool	commandPositionConversion () throw (TraCIException)
bool	commandScenario () throw (TraCIException)
bool	commandSetMaximumSpeed () throw (TraCIException, std::invalid_argument)
bool	commandSimulationParameter () throw (TraCIException)
bool	commandSlowDown () throw (TraCIException)
bool	commandStopNode () throw (TraCIException, std::invalid_argument)
bool	commandSubscribeDomain () throw (TraCIException)
bool	commandSubscribeLifecycles () throw (TraCIException)
bool	commandUnsubscribeDomain () throw (TraCIException)
bool	commandUnsubscribeLifecycles () throw (TraCIException)
bool	commandUpdateCalibrator () throw (TraCIException)
TraCIServer::RoadMapPos	convertCartesianToRoadMap (Position2D pos)
void	convertExt2IntId (int extId, std::string &intId)
Position2D	convertRoadMapToCartesian (TraCIServer::RoadMapPos pos) throw (TraCIException)
int	dispatchCommand () throw (TraCIException, std::invalid_argument)
const Boundary &	getNetBoundary ()
PointOfInterest *	getPoiByExtId (int extId)
Polygon2D *	getPolygonByExtId (int extId)
MSTrafficLightLogic *	getTLLogicByExtId (int extId)
MSVehicle *	getVehicleByExtId (int extId)
void	handleDomainSubscriptions (const SUMOTime &currentTime, const std::map< int, const MSVehicle * > &activeEquippedVehicles) throw (TraCIException)
void	handleLifecycleSubscriptions () throw (TraCIException)
std::string	handlePoiDomain (bool isWriteCommand, tcpip::Storage &response) throw (TraCIException)
std::string	handlePolygonDomain (bool isWriteCommand, tcpip::Storage &response) throw (TraCIException)
std::string	handleRoadMapDomain (bool isWriteCommand, tcpip::Storage &response) throw (TraCIException)
std::string	handleTrafficLightDomain (bool isWriteCommand, tcpip::Storage &response) throw (TraCIException)
std::string	handleVehicleDomain (bool isWriteCommand, tcpip::Storage &response) throw (TraCIException)
void	postProcessSimulationStep () throw (TraCIException, std::invalid_argument)
void	postProcessSimulationStep2 () throw (TraCIException, std::invalid_argument)
bool	processSingleSubscription (const TraCIServer::Subscription &s, tcpip::Storage &writeInto, std::string &errors) throw (TraCIException)
	TraCIServer ()
void	writeStatusCmd (int commandId, int status, std::string description)
virtual	~TraCIServer (void) throw ()
Private Attributes
std::map< std::string, int >	equippedVehicles_
std::map< int, std::string >	ext2intId
bool	isMapChanged_
std::set< int >	myCreatedVehicles
std::set< int >	myDestroyedVehicles
bool	myDoingSimStep
std::map< int, std::list < std::pair< int, int > > >	myDomainSubscriptions
tcpip::Storage	myInputStorage
std::set< int >	myLifecycleSubscriptions
std::set< int >	myLivingVehicles
tcpip::Storage	myOutputStorage
std::vector< Subscription >	mySubscriptions
std::map< MSNet::VehicleState, std::vector< std::string > >	myVehicleStateChanges
std::set< MSVehicle * >	myVehiclesToReroute
Boundary *	netBoundary_
int	numEquippedVehicles_
float	penetration_
std::map< int, std::string >	poiExt2IntId
std::map< std::string, int >	poiInt2ExtId
std::map< int, std::string >	polygonExt2IntId
std::map< std::string, int >	polygonInt2ExtId
std::string	routeFile_
int	simStepCommand
tcpip::Socket *	socket_
SUMOTime	targetTime_
int	totalNumVehicles_
std::map< int, std::string >	trafficLightsExt2IntId
std::map< std::string, int >	trafficLightsInt2ExtId
Static Private Attributes
static bool	closeConnection_ = false
static TraCIServer *	instance_ = 0
Data Structures
struct	RoadMapPos
class	Subscription

---

Constructor & Destructor Documentation

TraCIServer::TraCIServer

(

)

[private]

Definition at line 110 of file TraCIServer.cpp.

References MSNet::addVehicleStateListener(), MSTLLogicControl::getAllTLIds(), MsgHandler::getErrorInstance(), OptionsCont::getFloat(), MSNet::getInstance(), OptionsCont::getInt(), ShapeContainer::getMaxLayer(), MsgHandler::getMessageInstance(), ShapeContainer::getMinLayer(), OptionsCont::getOptions(), ShapeContainer::getPOICont(), ShapeContainer::getPolygonCont(), XMLSubSys::getSAXReader(), MSNet::getShapeContainer(), OptionsCont::getString(), OptionsCont::getStringVector(), MSNet::getTLSControl(), traci::TraCIHandler::getTotalVehicleCount(), MsgHandler::getWarningInstance(), MSGlobals::gUsingInternalLanes, MsgHandler::inform(), OptionsCont::isSet(), OptionsCont::isUsableFileList(), traci::TraCIHandler::resetTotalVehicleCount(), GenericSAXHandler::setFileName(), toString(), MSNet::VEHICLE_STATE_ARRIVED, MSNet::VEHICLE_STATE_BUILT, MSNet::VEHICLE_STATE_DEPARTED, MSNet::VEHICLE_STATE_ENDING_TELEPORT, MSNet::VEHICLE_STATE_STARTING_TELEPORT, MsgHandler::wasInformed(), and tcpip::SocketException::what().

                         {
    myVehicleStateChanges[MSNet::VEHICLE_STATE_BUILT] = std::vector<std::string>();
    myVehicleStateChanges[MSNet::VEHICLE_STATE_DEPARTED] = std::vector<std::string>();
    myVehicleStateChanges[MSNet::VEHICLE_STATE_STARTING_TELEPORT] = std::vector<std::string>();
    myVehicleStateChanges[MSNet::VEHICLE_STATE_ENDING_TELEPORT] = std::vector<std::string>();
    myVehicleStateChanges[MSNet::VEHICLE_STATE_ARRIVED] = std::vector<std::string>();
    MSNet::getInstance()->addVehicleStateListener(this);

    OptionsCont &oc = OptionsCont::getOptions();
    targetTime_ = 0;
    penetration_ = oc.getFloat("penetration");
    routeFile_ = oc.getString("route-files");
    isMapChanged_ = true;
    numEquippedVehicles_ = 0;
    totalNumVehicles_ = 0;
    closeConnection_ = false;
    netBoundary_ = NULL;
    myDoingSimStep = false;

    // display warning if internal lanes are not used
    if (!MSGlobals::gUsingInternalLanes) {
        MsgHandler::getWarningInstance()->inform("Starting TraCI without using internal lanes!");
        MsgHandler::getWarningInstance()->inform("Vehicles will jump over junctions.", false);
        MsgHandler::getWarningInstance()->inform("Use without option --no-internal-links to avoid unexpected behavior", false);
    }

    // map the internal id of all traffic lights, polygons and poi to external id and vice versa
    trafficLightsInt2ExtId.clear();
    trafficLightsExt2IntId.clear();
    poiExt2IntId.clear();
    poiInt2ExtId.clear();
    polygonExt2IntId.clear();
    polygonInt2ExtId.clear();
    int extId = 0;
    std::vector<std::string> tllIds = MSNet::getInstance()->getTLSControl().getAllTLIds();
    for (std::vector<std::string>::iterator it=tllIds.begin(); it != tllIds.end(); it++) {
        trafficLightsInt2ExtId[(*it)] = extId;
        trafficLightsExt2IntId[extId] = (*it);
//      cerr << "TL int=" << *it << " --> ext=" << extId << endl;
        extId++;
    }
    int poiId = 0;
    int polyId = 0;
    ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
    for (int i = shapeCont.getMinLayer(); i <= shapeCont.getMaxLayer(); i++) {
        std::vector<PointOfInterest*> poiList = shapeCont.getPOICont(i).getTempVector();
        for (std::vector<PointOfInterest*>::iterator it=poiList.begin(); it != poiList.end(); it++) {
            poiInt2ExtId[(*it)->getID()] = poiId;
            poiExt2IntId[poiId] = (*it)->getID();
            poiId++;
        }
        std::vector<Polygon2D*> polyList = shapeCont.getPolygonCont(i).getTempVector();
        for (std::vector<Polygon2D*>::iterator it=polyList.begin(); it != polyList.end(); it++) {
            polygonInt2ExtId[(*it)->getID()] = polyId;
            polygonExt2IntId[polyId] = (*it)->getID();
            polyId++;
        }
    }

    // determine the maximum number of vehicles by searching route and additional input files for "vehicle" tags
    TraCIHandler xmlHandler;
    SAX2XMLReader* xmlParser = XMLSubSys::getSAXReader(xmlHandler);

    // parse route files
    if (oc.isSet("route-files")) {
        std::vector<std::string> fileList = oc.getStringVector("route-files");
        for (std::vector<std::string>::iterator file=fileList.begin(); file != fileList.end(); file++) {
            if (oc.isUsableFileList("route-files")) {
                xmlHandler.setFileName((*file));
                xmlHandler.resetTotalVehicleCount();
                xmlParser->parse(file->c_str());

                if (!MsgHandler::getErrorInstance()->wasInformed()) {
                    totalNumVehicles_ += xmlHandler.getTotalVehicleCount();
                }
            }
        }
    }

    // parse additional files
    if (oc.isSet("additional-files")) {
        std::vector<std::string> fileList = oc.getStringVector("additional-files");
        for (std::vector<std::string>::iterator file = fileList.begin(); file != fileList.end(); file++) {
            if (oc.isUsableFileList("additional-files")) {
                xmlHandler.setFileName((*file));
                xmlHandler.resetTotalVehicleCount();
                xmlParser->parse(file->c_str());

                if (!MsgHandler::getErrorInstance()->wasInformed()) {
                    totalNumVehicles_ += xmlHandler.getTotalVehicleCount();
                }
            }
        }
    }

    delete xmlParser;

    try {
        int port = oc.getInt("remote-port");
        // Opens listening socket
        MsgHandler::getMessageInstance()->inform("***Starting server on port " + toString(port) + " ***");
        socket_ = new Socket(port);
        socket_->accept();
        // When got here, a client has connected
    } catch (SocketException &e) {
        throw ProcessError(e.what());
    }

}

TraCIServer::~TraCIServer

(

void

)

throw () [private, virtual]

Definition at line 222 of file TraCIServer.cpp.

References MSNet::getInstance(), and MSNet::removeVehicleStateListener().

                                  {
    MSNet::getInstance()->removeVehicleStateListener(this);
    if (socket_ != NULL) {
        socket_->close();
        delete socket_;
    }
    if (netBoundary_ != NULL) delete netBoundary_;
}

---

Member Function Documentation

bool TraCIServer::addSubscription

(

int

commandId

)

throw (TraCIException) [private]

Definition at line 3069 of file TraCIServer.cpp.

References traci::TraCIServer::Subscription::commandId, traci::TraCIServer::Subscription::endTime, MSNet::getCurrentTimeStep(), MSNet::getInstance(), RTYPE_ERR, and RTYPE_OK.

                                                                {
    SUMOTime beginTime = myInputStorage.readInt();
    SUMOTime endTime = myInputStorage.readInt();
    std::string id = myInputStorage.readString();
    int no = myInputStorage.readUnsignedByte();
    std::vector<int> variables;
    for (int i=0; i<no; ++i) {
        variables.push_back(myInputStorage.readUnsignedByte());
    }
    // check subscribe/unsubscribe
    bool ok = true;
    if (variables.size()==0) {
        // try unsubscribe
        bool found = false;
        for (std::vector<Subscription>::iterator j=mySubscriptions.begin(); j!=mySubscriptions.end();) {
            if ((*j).id==id&&(*j).commandId==commandId) {
                j = mySubscriptions.erase(j);
                found = true;
                continue;
            }
            ++j;
        }
        if (found) {
            writeStatusCmd(commandId, RTYPE_OK, "");
        } else {
            writeStatusCmd(commandId, RTYPE_OK, "The subscription to remove was not found.");
        }
    } else {
        // process subscription
        Subscription s(commandId, id, variables, beginTime, endTime);
        tcpip::Storage writeInto;
        std::string errors;
        if (s.endTime<MSNet::getInstance()->getCurrentTimeStep()) {
            processSingleSubscription(s, writeInto, errors);
            writeStatusCmd(s.commandId, RTYPE_ERR, "Subscription has ended.");
        } else {
            if (processSingleSubscription(s, writeInto, errors)) {
                mySubscriptions.push_back(s);
                writeStatusCmd(s.commandId, RTYPE_OK, "");
            } else {
                writeStatusCmd(s.commandId, RTYPE_ERR, "Could not add subscription (" + errors + ").");
            }
        }
        myOutputStorage.writeStorage(writeInto);
    }
    return ok;
}

void TraCIServer::close

(

)

[static]

Definition at line 234 of file TraCIServer.cpp.

Referenced by MSNet::closeSimulation().

                   {
    if (instance_!=0) {
        delete instance_;
        instance_ = 0;
        closeConnection_ = true;
    }
}

bool TraCIServer::commandAddVehicle

(

)

throw (TraCIException) [private]

Definition at line 1420 of file TraCIServer.cpp.

References MSVehicleControl::addVehicle(), MSVehicleControl::buildVehicle(), CMD_ADDVEHICLE, CMD_STOP, MSVehicleControl::deleteVehicle(), SUMOVehicleParameter::depart, MSLane::dictionary(), MSRoute::dictionary(), MSNet::getCurrentTimeStep(), MSRoute::getEdges(), MSVehicle::getID(), MSNet::getInstance(), MSVehicle::getMaxSpeed(), MSLane::getMaxSpeed(), MSNet::getVehicleControl(), MSVehicleControl::getVType(), SUMOVehicleParameter::id, MSLane::isEmissionSuccess(), MIN2(), MIN3(), MSVehicle::onDepart(), RTYPE_ERR, RTYPE_OK, and SUMOReal.

                                                     {

    // read parameters
    std::string vehicleId = myInputStorage.readString();
    std::string vehicleTypeId = myInputStorage.readString();
    std::string routeId = myInputStorage.readString();
    std::string laneId = myInputStorage.readString();
    SUMOReal emitPosition = myInputStorage.readFloat();
    SUMOReal emitSpeed = myInputStorage.readFloat();

    // find vehicleType
    MSVehicleType *vehicleType = MSNet::getInstance()->getVehicleControl().getVType(vehicleTypeId);
    if (!vehicleType) {
        writeStatusCmd(CMD_ADDVEHICLE, RTYPE_ERR, "Invalid vehicleTypeId: '"+vehicleTypeId+"'");
        return false;
    }

    // find route
    const MSRoute *route = MSRoute::dictionary(routeId);
    if (!route) {
        writeStatusCmd(CMD_ADDVEHICLE, RTYPE_ERR, "Invalid routeId: '"+routeId+"'");
        return false;
    }

    // find lane
    MSLane *lane;
    if (laneId != "") {
        lane = MSLane::dictionary(laneId);
        if (!lane) {
            writeStatusCmd(CMD_ADDVEHICLE, RTYPE_ERR, "Invalid laneId: '"+laneId+"'");
            return false;
        }
    } else {
        lane = route->getEdges()[0]->getLanes()[0];
        if (!lane) {
            writeStatusCmd(CMD_STOP, RTYPE_ERR, "Could not find first lane of first edge in routeId '"+routeId+"'");
            return false;
        }
    }

    // build vehicle
    SUMOVehicleParameter* vehicleParams = new SUMOVehicleParameter();
    vehicleParams->id = vehicleId;
    vehicleParams->depart = MSNet::getInstance()->getCurrentTimeStep()+1;
    MSVehicle *vehicle = MSNet::getInstance()->getVehicleControl().buildVehicle(vehicleParams, route, vehicleType);
    if (vehicle == NULL) {
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "Could not build vehicle");
        return false;
    }

    // calculate speed
    float clippedEmitSpeed;
    if (emitSpeed<0) {
        clippedEmitSpeed = MIN2(lane->getMaxSpeed(), vehicle->getMaxSpeed());
    } else {
        clippedEmitSpeed = MIN3(lane->getMaxSpeed(), vehicle->getMaxSpeed(), emitSpeed);
    }

    // insert vehicle into the dictionary
    if (!MSNet::getInstance()->getVehicleControl().addVehicle(vehicle->getID(), vehicle)) {
        writeStatusCmd(CMD_ADDVEHICLE, RTYPE_ERR, "Could not add vehicle to VehicleControl");
        return false;
    }

    // try to emit
    if (!lane->isEmissionSuccess(vehicle, clippedEmitSpeed, emitPosition, true)) {
        MSNet::getInstance()->getVehicleControl().deleteVehicle(vehicle);
        writeStatusCmd(CMD_ADDVEHICLE, RTYPE_ERR, "Could not emit vehicle");
        return false;
    }

    // exec callback
    vehicle->onDepart();

    // create a reply message
    writeStatusCmd(CMD_ADDVEHICLE, RTYPE_OK, "");

    return true;
}

bool TraCIServer::commandChangeLane

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 823 of file TraCIServer.cpp.

References CMD_CHANGELANE, MSVehicle::getEdge(), MSEdge::getLanes(), RTYPE_ERR, RTYPE_OK, and MSVehicle::startLaneChange().

                                                                          {
    // NodeId
    MSVehicle* veh = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)
    // Lane ID
    char laneIndex = myInputStorage.readByte();
    // stickyTime
    SUMOTime stickyTime = myInputStorage.readInt();

    if (veh == NULL) {
        writeStatusCmd(CMD_CHANGELANE, RTYPE_ERR, "Can not retrieve node with given ID");
        return false;
    }

    /*const MSEdge* const road = veh->getEdge();
    const std::vector<MSLane*> &allLanes = road->getLanes();*/
    if ((laneIndex < 0) || (laneIndex >= veh->getEdge()->getLanes().size())) {
        writeStatusCmd(CMD_CHANGELANE, RTYPE_ERR, "No lane existing with given id on the current road");
        return false;
    }

    // Forward command to vehicle
    veh->startLaneChange(static_cast<unsigned>(laneIndex), static_cast<SUMOTime>(stickyTime));

    // create a reply message
    writeStatusCmd(CMD_CHANGELANE, RTYPE_OK, "");

    return true;
}

bool TraCIServer::commandChangeRoute

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 854 of file TraCIServer.cpp.

References MSEdgeWeightsStorage::addTravelTime(), CMD_CHANGEROUTE, MSEdge::dictionary(), MSNet::getCurrentTimeStep(), MSNet::getInstance(), OptionsCont::getOptions(), MSNet::getWeightsStorage(), MSVehicle::getWeightsStorage(), MSEdgeWeightsStorage::knowsTravelTime(), MSEdgeWeightsStorage::removeTravelTime(), RTYPE_ERR, RTYPE_OK, string2time(), SUMOReal, SUMOTime_MAX, toString(), and MSVehicle::willPass().

                                                                           {
    // NodeId
    int vehId = myInputStorage.readInt();
    MSVehicle* veh = getVehicleByExtId(vehId);   // external node id (equipped vehicle number)
    // edgeID
    std::string edgeId = myInputStorage.readString();
    MSEdge* edge = MSEdge::dictionary(edgeId);
    // travelTime
    double travelTime = myInputStorage.readDouble();
    if (veh == NULL) {
        writeStatusCmd(CMD_CHANGEROUTE, RTYPE_ERR, "Can not retrieve node with ID " + toString(vehId));
        return false;
    }
    if (edge == NULL) {
        writeStatusCmd(CMD_CHANGEROUTE, RTYPE_ERR, "Can not retrieve edge with ID " + edgeId);
        return false;
    }
    //
    SUMOTime currentTime = MSNet::getInstance()->getCurrentTimeStep() / 1000.;
    MSNet::EdgeWeightsProxi proxi(veh->getWeightsStorage(), MSNet::getInstance()->getWeightsStorage());
    SUMOReal effortBefore = proxi.getTravelTime(edge, veh, currentTime);
    bool hadError = false;
    if (travelTime < 0) {
        if (!veh->getWeightsStorage().knowsTravelTime(edge)) {
            hadError = true;
        }
        veh->getWeightsStorage().removeTravelTime(edge);
    } else {
        SUMOTime end = string2time(OptionsCont::getOptions().getString("end"));
        if(end<0) {
            end = SUMOTime_MAX;
        }
        veh->getWeightsStorage().addTravelTime(edge, currentTime, (SUMOReal) end / 1000., travelTime);
    }
    SUMOReal effortAfter = proxi.getTravelTime(edge, veh, currentTime);
    if (myVehiclesToReroute.find(veh)==myVehiclesToReroute.end() && (effortBefore != effortAfter)) {
        // there is only a need to reroute if either the weight decreases or the edge is on our current route
        if ((effortBefore > effortAfter) ^ veh->willPass(edge)) {
            myVehiclesToReroute.insert(veh);
        }
    }
    if (!hadError) {
        writeStatusCmd(CMD_CHANGEROUTE, RTYPE_OK, "");
        return true;
    } else {
        writeStatusCmd(CMD_CHANGEROUTE, RTYPE_ERR, "Could not (re-)set travel time properly");
        return false;
    }
}

bool TraCIServer::commandChangeTarget

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 906 of file TraCIServer.cpp.

References CMD_CHANGETARGET, MSEdge::dictionary(), MSEdge::dictSize(), MSNet::getCurrentTimeStep(), MSVehicle::getEdge(), MSVehicle::getID(), MSNet::getInstance(), MSNet::EdgeWeightsProxi::getTravelTime(), MSNet::getWeightsStorage(), MSVehicle::getWeightsStorage(), MSVehicle::replaceRoute(), RTYPE_ERR, and RTYPE_OK.

                                                                            {
    // NodeId
    MSVehicle* veh = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)
    // EdgeId
    std::string edgeID = myInputStorage.readString();

    // destination edge
    const MSEdge* destEdge = MSEdge::dictionary(edgeID);

    if (veh == NULL) {
        writeStatusCmd(CMD_CHANGETARGET, RTYPE_ERR, "Can not retrieve node with given ID");
        return false;
    }

    if (destEdge == NULL) {
        writeStatusCmd(CMD_CHANGETARGET, RTYPE_ERR, "Can not retrieve road with ID " + edgeID);
        return false;
    }

    // build a new route between the vehicle's current edge and destination edge
    MSEdgeVector newRoute;
    const MSEdge* currentEdge = veh->getEdge();
    MSNet::EdgeWeightsProxi proxi(veh->getWeightsStorage(), MSNet::getInstance()->getWeightsStorage());
    DijkstraRouterTT_ByProxi<MSEdge, SUMOVehicle, prohibited_withRestrictions<MSEdge, SUMOVehicle>, MSNet::EdgeWeightsProxi> router(MSEdge::dictSize(), true, &proxi, &MSNet::EdgeWeightsProxi::getTravelTime);
    router.compute(currentEdge, destEdge, (const MSVehicle* const) veh,
                   MSNet::getInstance()->getCurrentTimeStep(), newRoute);
    // replace the vehicle's route by the new one
    if (veh->replaceRoute(newRoute, MSNet::getInstance()->getCurrentTimeStep())) {
        writeStatusCmd(CMD_CHANGETARGET, RTYPE_OK, "");
        return true;
    } else {
        writeStatusCmd(CMD_CHANGETARGET, RTYPE_ERR, "Route replacement failed for " + veh->getID());
        return false;
    }
}

bool TraCIServer::commandCloseConnection

(

)

throw (TraCIException) [private]

Definition at line 1144 of file TraCIServer.cpp.

References CMD_CLOSE, and RTYPE_OK.

                                                          {
    closeConnection_ = true;
    // write answer
    writeStatusCmd(CMD_CLOSE, RTYPE_OK, "Goodbye");
    return true;
}

bool TraCIServer::commandDistanceRequest

(

)

throw (TraCIException) [private]

Definition at line 1503 of file TraCIServer.cpp.

References CMD_DISTANCEREQUEST, TraCIDijkstraRouter< E >::compute(), RGBColor::DEFAULT_COLOR, MSEdge::dictionary(), MSEdge::dictSize(), Position2D::distanceTo(), MSNet::getCurrentTimeStep(), MSRoute::getDistanceBetween(), MSNet::getInstance(), traci::TraCIServer::RoadMapPos::laneId, traci::TraCIServer::RoadMapPos::pos, POSITION_2_5D, POSITION_2D, POSITION_3D, POSITION_ROADMAP, REQUEST_AIRDIST, REQUEST_DRIVINGDIST, traci::TraCIServer::RoadMapPos::roadId, RTYPE_ERR, RTYPE_OK, Position2D::set(), and traci::TraCIException::what().

                                                          {
    Position2D pos1;
    Position2D pos2;
    RoadMapPos roadPos1;
    RoadMapPos roadPos2;
    const std::vector<MSLane*>* lanes;

    // read position 1
    int posType = myInputStorage.readUnsignedByte();
    switch (posType) {
    case POSITION_ROADMAP:
        roadPos1.roadId = myInputStorage.readString();
        roadPos1.pos = myInputStorage.readFloat();
        roadPos1.laneId = myInputStorage.readUnsignedByte();
        try {
            pos1 = convertRoadMapToCartesian(roadPos1);
        } catch (TraCIException &e) {
            writeStatusCmd(CMD_DISTANCEREQUEST, RTYPE_ERR, e.what());
            return false;
        }
        break;
    case POSITION_2D:
    case POSITION_2_5D:
    case POSITION_3D: {
        float p1x = myInputStorage.readFloat();
        float p1y = myInputStorage.readFloat();
        pos1.set(p1x, p1y);
    }
    if ((posType == POSITION_2_5D) || (posType == POSITION_3D)) {
        myInputStorage.readFloat();     // z value is ignored
    }
    roadPos1 = convertCartesianToRoadMap(pos1);
    break;
    default:
        writeStatusCmd(CMD_DISTANCEREQUEST, RTYPE_ERR, "Unknown position format used for distance request");
        return false;
    }

    // read position 2
    posType = myInputStorage.readUnsignedByte();
    switch (posType) {
    case POSITION_ROADMAP:
        roadPos2.roadId = myInputStorage.readString();
        roadPos2.pos = myInputStorage.readFloat();
        roadPos2.laneId = myInputStorage.readUnsignedByte();
        try {
            pos2 = convertRoadMapToCartesian(roadPos2);
        } catch (TraCIException &e) {
            writeStatusCmd(CMD_DISTANCEREQUEST, RTYPE_ERR, e.what());
            return false;
        }
        break;
    case POSITION_2D:
    case POSITION_2_5D:
    case POSITION_3D: {
        float p2x = myInputStorage.readFloat();
        float p2y = myInputStorage.readFloat();
        pos2.set(p2x, p2y);
    }
    if ((posType == POSITION_2_5D) || (posType == POSITION_3D)) {
        myInputStorage.readFloat();     // z value is ignored
    }
    roadPos2 = convertCartesianToRoadMap(pos2);
    break;
    default:
        writeStatusCmd(CMD_DISTANCEREQUEST, RTYPE_ERR, "Unknown position format used for distance request");
        return false;
    }

    // read distance type
    int distType = myInputStorage.readUnsignedByte();

    float distance = 0.0;
    if (distType == REQUEST_DRIVINGDIST) {
        // compute driving distance
        std::vector<const MSEdge*> edges;
        TraCIDijkstraRouter<MSEdge> router(MSEdge::dictSize());

        if ((roadPos1.roadId.compare(roadPos2.roadId) == 0)
                && (roadPos1.pos <= roadPos2.pos)) {
            distance = roadPos2.pos - roadPos1.pos;
        } else {
            router.compute(MSEdge::dictionary(roadPos1.roadId), MSEdge::dictionary(roadPos2.roadId), NULL,
                           MSNet::getInstance()->getCurrentTimeStep(), edges);
            MSRoute route("", edges, false, RGBColor::DEFAULT_COLOR, std::vector<SUMOVehicleParameter::Stop>());
            distance = static_cast<float>(route.getDistanceBetween(roadPos1.pos, roadPos2.pos,
                                          MSEdge::dictionary(roadPos1.roadId), MSEdge::dictionary(roadPos2.roadId)));
        }
    } else {
        // compute air distance (default)
        // correct the distance type in case it was not valid
        distType = REQUEST_AIRDIST;
        distance = static_cast<float>(pos1.distanceTo(pos2));
    }

    // acknowledge distance request
    writeStatusCmd(CMD_DISTANCEREQUEST, RTYPE_OK, "");
    // write response command
    myOutputStorage.writeUnsignedByte(1 + 1 + 1 + 4);   // length
    myOutputStorage.writeUnsignedByte(CMD_DISTANCEREQUEST);     // command type
    myOutputStorage.writeUnsignedByte(distType);        // distance type
    myOutputStorage.writeFloat(distance);   // distance;
    return true;
}

bool TraCIServer::commandGetAllTLIds

(

)

throw (TraCIException) [private]

Definition at line 944 of file TraCIServer.cpp.

References CMD_GETALLTLIDS, CMD_TLIDLIST, MSTLLogicControl::getAllTLIds(), MSNet::getInstance(), MSNet::getTLSControl(), RTYPE_ERR, and RTYPE_OK.

                                                      {
    tcpip::Storage tempMsg;

    // get the TLLogicControl
    MSTLLogicControl &tlsControl = MSNet::getInstance()->getTLSControl();
    // get the ids
    std::vector<std::string> idList = tlsControl.getAllTLIds();

    if (idList.size() == 0) {
        // create negative response message
        writeStatusCmd(CMD_GETALLTLIDS, RTYPE_ERR, "Could not retrieve any traffic light id");
        return false;
    }

    // create positive response message
    writeStatusCmd(CMD_GETALLTLIDS, RTYPE_OK, "");

    // create a response command for each std::string id
    for (std::vector<std::string>::iterator iter = idList.begin(); iter != idList.end(); iter++) {
        // command length
        myOutputStorage.writeByte(2 + (4 + (*iter).size()));
        // command type
        myOutputStorage.writeByte(CMD_TLIDLIST);
        // id string
        myOutputStorage.writeString((*iter));
    }
    return true;
}

bool TraCIServer::commandGetTLStatus

(

)

throw (TraCIException) [private]

Definition at line 975 of file TraCIServer.cpp.

References CMD_GETTLSTATUS, CMD_TLSWITCH, DELTA_T, MSTrafficLightLogic::getCurrentPhaseDef(), MSTrafficLightLogic::getCurrentPhaseIndex(), MSEdge::getID(), MSTrafficLightLogic::getIndexFromOffset(), MSTrafficLightLogic::getLanesAt(), MSTrafficLightLogic::getLinks(), MSTrafficLightLogic::getPhase(), MSTrafficLightLogic::getPhaseIndexAtTime(), MSPhaseDefinition::getSignalState(), MSLink::LINKSTATE_TL_GREEN_MAJOR, MSLink::LINKSTATE_TL_GREEN_MINOR, MSLink::LINKSTATE_TL_OFF_BLINKING, MSLink::LINKSTATE_TL_OFF_NOSIGNAL, MSLink::LINKSTATE_TL_RED, MSLink::LINKSTATE_TL_YELLOW_MAJOR, MSLink::LINKSTATE_TL_YELLOW_MINOR, tcpip::Storage::reset(), RTYPE_ERR, RTYPE_OK, tcpip::Storage::size(), TLPHASE_BLINKING, TLPHASE_GREEN, TLPHASE_NOSIGNAL, TLPHASE_RED, tcpip::Storage::writeFloat(), tcpip::Storage::writeInt(), tcpip::Storage::writeString(), and tcpip::Storage::writeUnsignedByte().

                                                      {
    SUMOTime lookback = 60*1000.; // Time to look in history for recognizing yellowTimes

    tcpip::Storage tempMsg;

    // trafic light id
    int extId = myInputStorage.readInt();
    // start of time interval
    SUMOTime timeFrom = myInputStorage.readInt();
    // end of time interval
    SUMOTime timeTo = myInputStorage.readInt();

    // get the running programm of the traffic light
    MSTrafficLightLogic* const tlLogic = getTLLogicByExtId(extId);

    // error checking
    if (tlLogic == NULL) {
        writeStatusCmd(CMD_GETTLSTATUS, RTYPE_ERR, "Could not retrieve traffic light with given id");
        return false;
    }
    if ((timeTo < timeFrom) || (timeTo < 0) || (timeFrom < 0)) {
        writeStatusCmd(CMD_GETTLSTATUS, RTYPE_ERR, "The given time interval is not valid");
        return false;
    }

    // acknowledge the request
    writeStatusCmd(CMD_GETTLSTATUS, RTYPE_OK, "");
    std::vector<MSLink::LinkState> linkStates;
    std::vector<double> yellowTimes;
    size_t lastStep = tlLogic->getCurrentPhaseIndex();
    MSPhaseDefinition phase = tlLogic->getCurrentPhaseDef();
    MSTrafficLightLogic::LinkVectorVector affectedLinks = tlLogic->getLinks();

    // save the current link states
    for (int i = 0; i < affectedLinks.size(); i++) {
        linkStates.push_back(phase.getSignalState(i));
        yellowTimes.push_back(-1);
    }

    // check every second of the given time interval for a switch in the traffic light's phases
    for (SUMOTime time = timeFrom - lookback; time <= timeTo; time+=DELTA_T) {
        if (time < 0) time = 0;
        size_t position = tlLogic->getPhaseIndexAtTime(time);
        size_t currentStep = tlLogic->getIndexFromOffset(position);

        if (currentStep != lastStep) {
            lastStep = currentStep;
            phase = tlLogic->getPhase(currentStep);

            // for every link of the tl's junction, compare the actual and the last red/green state
            // for each link with new red/green status, write a TLSWITCH command
            std::map<const MSEdge*, pair<const MSEdge*, int> > writtenEdgePairs;
            for (int i = 0; i < linkStates.size(); i++) {
                MSLink::LinkState nextLinkState = phase.getSignalState(i);

                if (nextLinkState == MSLink::LINKSTATE_TL_YELLOW_MAJOR || nextLinkState == MSLink::LINKSTATE_TL_YELLOW_MINOR) {
                    if (yellowTimes[i] < 0) yellowTimes[i] = time;
                } else {
                    if (nextLinkState != linkStates[i] && time >= timeFrom) {
                        linkStates[i] = nextLinkState;

                        // get the group of links that is affected by the changed light status
                        MSTrafficLightLogic::LinkVector linkGroup = affectedLinks[i];
                        // get the group of preceding lanes of the link group
                        MSTrafficLightLogic::LaneVector laneGroup = tlLogic->getLanesAt(i);

                        for (int j = 0; j < linkGroup.size(); j++) {
                            MSEdge &precEdge = laneGroup[j]->getEdge();
                            MSEdge &succEdge = linkGroup[j]->getLane()->getEdge();

                            // for each pair of edges and every different tl state, write only one tl switch command
                            std::map<const MSEdge*, pair<const MSEdge*, int> >::iterator itPair = writtenEdgePairs.find(&precEdge);
                            if (itPair != writtenEdgePairs.end()) {
                                if (itPair->second.first == &succEdge && itPair->second.second == nextLinkState) {
                                    continue;
                                }
                            }
                            // remember the current edge pair and tl status
                            writtenEdgePairs[&precEdge] = std::make_pair(&succEdge, nextLinkState);

                            // time of the switch
                            tempMsg.writeInt(time);
                            // preceeding edge id
                            tempMsg.writeString(precEdge.getID());
                            // traffic light's position on preceeding edge
                            tempMsg.writeFloat(laneGroup[j]->getShape().length());
                            // succeeding edge id
                            tempMsg.writeString(succEdge.getID());
                            // new status
                            switch (nextLinkState) {
                            case MSLink::LINKSTATE_TL_GREEN_MAJOR:
                            case MSLink::LINKSTATE_TL_GREEN_MINOR:
                                tempMsg.writeUnsignedByte(TLPHASE_GREEN);
                                break;
                            case MSLink::LINKSTATE_TL_RED:
                                tempMsg.writeUnsignedByte(TLPHASE_RED);
                                break;
                            case MSLink::LINKSTATE_TL_OFF_BLINKING:
                                tempMsg.writeUnsignedByte(TLPHASE_BLINKING);
                                break;
                            case MSLink::LINKSTATE_TL_OFF_NOSIGNAL:
                                tempMsg.writeUnsignedByte(TLPHASE_NOSIGNAL);
                                break;
                            default:
                                tempMsg.writeUnsignedByte(TLPHASE_NOSIGNAL);
                            }
                            //yellow time
                            tempMsg.writeInt(yellowTimes[i]<0 ? 0 : time - yellowTimes[i]);

                            if (tempMsg.size() <= 253) {
                                // command length
                                myOutputStorage.writeUnsignedByte(1 + 1 + tempMsg.size());
                            } else {
                                // command length extended
                                myOutputStorage.writeUnsignedByte(0);
                                myOutputStorage.writeInt(1 + 4 + 1 + tempMsg.size());
                            }
                            // command type
                            myOutputStorage.writeUnsignedByte(CMD_TLSWITCH);
                            // command content
                            myOutputStorage.writeStorage(tempMsg);
                            tempMsg.reset();
                        }
                    }
                    yellowTimes[i] = -1;
                }
            }
        }
    }
    return true;
}

bool TraCIServer::commandPositionConversion

(

)

throw (TraCIException) [private]

Definition at line 1259 of file TraCIServer.cpp.

References CMD_POSITIONCONVERSION, traci::TraCIServer::RoadMapPos::laneId, traci::TraCIServer::RoadMapPos::pos, POSITION_2_5D, POSITION_2D, POSITION_3D, POSITION_ROADMAP, traci::TraCIServer::RoadMapPos::roadId, RTYPE_ERR, RTYPE_OK, tcpip::Storage::size(), traci::TraCIException::what(), tcpip::Storage::writeFloat(), tcpip::Storage::writeString(), tcpip::Storage::writeUnsignedByte(), Position2D::x(), and Position2D::y().

                                                             {
    tcpip::Storage tmpResult;
    RoadMapPos roadPos;
    Position2D cartesianPos;
    float x = 0;
    float y = 0;
    float z = 0;
    unsigned char destPosType;

    // actual position type that will be converted
    unsigned char srcPosType = myInputStorage.readUnsignedByte();

    switch (srcPosType) {
    case POSITION_2D:
    case POSITION_2_5D:
    case POSITION_3D:
        x = myInputStorage.readFloat();
        y = myInputStorage.readFloat();
        if (srcPosType != POSITION_2D) {
            z = myInputStorage.readFloat();
        }
        // destination position type
        destPosType = myInputStorage.readUnsignedByte();

        switch (destPosType) {
        case POSITION_ROADMAP:
            // convert road map to 3D position
            roadPos = convertCartesianToRoadMap(Position2D(x, y));

            // write result that is added to response msg
            tmpResult.writeUnsignedByte(POSITION_ROADMAP);
            tmpResult.writeString(roadPos.roadId);
            tmpResult.writeFloat(roadPos.pos);
            tmpResult.writeUnsignedByte(roadPos.laneId);
            break;
        case POSITION_3D:
            writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_ERR,
                           "Destination position type is same as source position type");
            return false;
        default:
            writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_ERR,
                           "Destination position type not supported");
            return false;
        }
        break;
    case POSITION_ROADMAP:
        roadPos.roadId = myInputStorage.readString();
        roadPos.pos = myInputStorage.readFloat();
        roadPos.laneId = myInputStorage.readUnsignedByte();

        // destination position type
        destPosType = myInputStorage.readUnsignedByte();

        switch (destPosType) {
        case POSITION_2D:
        case POSITION_2_5D:
        case POSITION_3D:
            //convert 3D to road map position
            try {
                Position2D result = convertRoadMapToCartesian(roadPos);
                x = result.x();
                y = result.y();
            } catch (TraCIException &e) {
                writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_ERR, e.what());
                return false;
            }

            // write result that is added to response msg
            tmpResult.writeUnsignedByte(destPosType);
            tmpResult.writeFloat(x);
            tmpResult.writeFloat(y);
            if (destPosType != POSITION_2D) {
                tmpResult.writeFloat(z);
            }
            break;
        case POSITION_ROADMAP:
            writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_ERR,
                           "Destination position type is same as source position type");
            return false;
        default:
            writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_ERR,
                           "Destination position type not supported");
            return false;
        }
        break;
    default:
        writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_ERR,
                       "Source position type not supported");
        return false;
    }

    // write response message
    writeStatusCmd(CMD_POSITIONCONVERSION, RTYPE_OK, "");
    // add converted Position to response
    myOutputStorage.writeUnsignedByte(1 + 1 + tmpResult.size() + 1);    // length
    myOutputStorage.writeUnsignedByte(CMD_POSITIONCONVERSION);  // command id
    myOutputStorage.writeStorage(tmpResult);    // position dependant part
    myOutputStorage.writeUnsignedByte(destPosType); // destination type
    return true;
}

bool TraCIServer::commandScenario

(

)

throw (TraCIException) [private]

Definition at line 1363 of file TraCIServer.cpp.

References CMD_SCENARIO, DOM_POI, DOM_POLYGON, DOM_ROADMAP, DOM_TRAFFICLIGHTS, DOM_VEHICLE, RTYPE_ERR, RTYPE_OK, tcpip::Storage::size(), and traci::TraCIException::what().

                                                   {
    Storage tmpResult;
    std::string warning = "";   // additional description for response

    // read/write flag
    bool isWriteCommand = myInputStorage.readUnsignedByte();

    // domain
    int domain = myInputStorage.readUnsignedByte();

    try {
        switch (domain) {
        case DOM_ROADMAP:
            warning = handleRoadMapDomain(isWriteCommand, tmpResult);
            break;
        case DOM_VEHICLE:
            warning = handleVehicleDomain(isWriteCommand, tmpResult);
            break;
        case DOM_TRAFFICLIGHTS:
            warning = handleTrafficLightDomain(isWriteCommand, tmpResult);
            break;
        case DOM_POI:
            warning = handlePoiDomain(isWriteCommand, tmpResult);
            break;
        case DOM_POLYGON:
            warning = handlePolygonDomain(isWriteCommand, tmpResult);
            break;
        default:
            writeStatusCmd(CMD_SCENARIO, RTYPE_ERR, "Unknown domain specified");
            return false;
        }
    } catch (TraCIException &e) {
        writeStatusCmd(CMD_SCENARIO, RTYPE_ERR, e.what());
        return false;
    }

    // write response message
    writeStatusCmd(CMD_SCENARIO, RTYPE_OK, warning);
    // if necessary, add Scenario command containing the read value
    if (!isWriteCommand) {
        if (tmpResult.size() <= 253) {
            myOutputStorage.writeUnsignedByte(1 + 1 + tmpResult.size());    // command length
            myOutputStorage.writeUnsignedByte(CMD_SCENARIO);    // command id
            myOutputStorage.writeStorage(tmpResult);    // variable dependant part
        } else {
            myOutputStorage.writeUnsignedByte(0);   // command length -> extended
            myOutputStorage.writeInt(1 + 4 + 1 + tmpResult.size());
            myOutputStorage.writeUnsignedByte(CMD_SCENARIO);    // command id
            myOutputStorage.writeStorage(tmpResult);    // variable dependant part
        }
    }
    return true;
}

bool TraCIServer::commandSetMaximumSpeed

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 508 of file TraCIServer.cpp.

References CMD_SETMAXSPEED, RTYPE_ERR, RTYPE_OK, MSVehicle::setIndividualMaxSpeed(), and MSVehicle::unsetIndividualMaxSpeed().

                                                                               {
    MSVehicle* veh = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)
    float maxspeed = myInputStorage.readFloat();

    if (veh == NULL) {
        writeStatusCmd(CMD_SETMAXSPEED, RTYPE_ERR, "Can not retrieve node with given ID");
        return false;
    }

    if (maxspeed>=0.0) {
        veh->setIndividualMaxSpeed(maxspeed);
    } else {
        veh->unsetIndividualMaxSpeed();
    }

    // create a reply message
    writeStatusCmd(CMD_SETMAXSPEED, RTYPE_OK, "");

    return true;
}

bool TraCIServer::commandSimulationParameter

(

)

throw (TraCIException) [private]

Definition at line 1154 of file TraCIServer.cpp.

References CMD_SIMPARAMETER, MSVehicle::getPosition(), RTYPE_ERR, RTYPE_NOTIMPLEMENTED, RTYPE_OK, tcpip::Storage::size(), tcpip::Storage::writeFloat(), Position2D::x(), and Position2D::y().

                                                              {
    bool setParameter = (myInputStorage.readByte() != 0);
    std::string parameter = myInputStorage.readString();

    // Prepare response
    tcpip::Storage answerTmp;

    if (parameter.compare("maxX")) {
        if (setParameter) {
            writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "maxX is a read only parameter");
            return false;
        } else {
            answerTmp.writeFloat(getNetBoundary().getWidth());
        }
    } else if (parameter.compare("maxY")) {
        if (setParameter) {
            writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "maxY is a read only parameter");
            return false;
        } else {
            answerTmp.writeFloat(getNetBoundary().getHeight());
        }
    } else if (parameter.compare("numberOfNodes")) {
        if (setParameter) {
            writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "numberOfNodes is a read only parameter");
            return false;
        } else {
            writeStatusCmd(CMD_SIMPARAMETER, RTYPE_NOTIMPLEMENTED, "numberOfNodes not implemented yet");
            return false;
            //answerTmp.writeInt( --- Don't know where to get that information ---);
        }
    } else if (parameter.compare("airDistance")) {
        MSVehicle* veh1 = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)
        MSVehicle* veh2 = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)

        if (veh1 != NULL && veh2 != NULL) {
            if (setParameter) {
                writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "airDistance is a read only parameter");
                return false;
            } else {
                float dx = veh1->getPosition().x() - veh2->getPosition().x();
                float dy = veh1->getPosition().y() - veh2->getPosition().y();
                answerTmp.writeFloat(sqrt(dx * dx + dy * dy));
            }
        } else {
            writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "Can not retrieve node with given ID");
            return false;
        }
    } else if (parameter.compare("drivingDistance")) {
        MSVehicle* veh1 = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)
        MSVehicle* veh2 = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)

        if (veh1 != NULL && veh2 != NULL) {
            if (setParameter) {
                writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "airDistance is a read only parameter");
                return false;
            } else {
                writeStatusCmd(CMD_SIMPARAMETER, RTYPE_NOTIMPLEMENTED, "drivingDistance not implemented yet");
                return false;
                //float dx = veh1->getPosition().x() - veh2->getPosition().x();
                //float dy = veh1->getPosition().y() - veh2->getPosition().y();
                //float distance = sqrt( dx * dx + dy * dy );
                // answerTmp.writeFloat( distance );
            }
        } else {
            writeStatusCmd(CMD_SIMPARAMETER, RTYPE_ERR, "Can not retrieve node with given ID");
            return false;
        }
    }

    // When we get here, the response is stored in answerTmp -> put into myOutputStorage
    writeStatusCmd(CMD_SIMPARAMETER, RTYPE_OK, "");

    // command length
    myOutputStorage.writeUnsignedByte(1 + 1 + 1 + 4 + static_cast<int>(parameter.length()) + answerTmp.size());
    // command type
    myOutputStorage.writeUnsignedByte(CMD_SIMPARAMETER);
    // answer only to getParameter commands as setParameter
    myOutputStorage.writeUnsignedByte(1);
    // Parameter
    myOutputStorage.writeString(parameter);
    // and the parameter dependant part
    myOutputStorage.writeStorage(answerTmp);
    return true;
}

bool TraCIServer::commandSlowDown

(

)

throw (TraCIException) [private]

Definition at line 1110 of file TraCIServer.cpp.

References CMD_SLOWDOWN, MSNet::getCurrentTimeStep(), MSNet::getInstance(), MAX2(), RTYPE_ERR, RTYPE_OK, and MSVehicle::startSpeedAdaption().

                                                   {
    // NodeId
    MSVehicle* veh = getVehicleByExtId(myInputStorage.readInt());   // external node id (equipped vehicle number)
    // speed
    float newSpeed = MAX2(myInputStorage.readFloat(), 0.0f);
    // time interval
    SUMOTime duration = myInputStorage.readInt();

    if (veh == NULL) {
        writeStatusCmd(CMD_SLOWDOWN, RTYPE_ERR, "Can not retrieve node with given ID");
        return false;
    }
    /*if (newSpeed < 0) {
        writeStatusCmd(CMD_SLOWDOWN, RTYPE_ERR, "Negative speed value");
        return false;
    }*/
    if (duration <= 0) {
        writeStatusCmd(CMD_SLOWDOWN, RTYPE_ERR, "Invalid time interval");
        return false;
    }

    if (!veh->startSpeedAdaption(newSpeed, duration, MSNet::getInstance()->getCurrentTimeStep())) {
        writeStatusCmd(CMD_SLOWDOWN, RTYPE_ERR, "Could not slow down");
        return false;
    }

    // create positive response message
    writeStatusCmd(CMD_SLOWDOWN, RTYPE_OK, "");
    return true;
}

bool TraCIServer::commandStopNode

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 716 of file TraCIServer.cpp.

References MSVehicle::addTraciStop(), CMD_STOP, MSEdge::dictionary(), MSLane::getID(), MSEdge::getLanes(), traci::TraCIServer::RoadMapPos::laneId, MSEdge::leftLane(), traci::TraCIServer::RoadMapPos::pos, POSITION_2D, POSITION_3D, POSITION_ROADMAP, MSEdge::rightLane(), traci::TraCIServer::RoadMapPos::roadId, RTYPE_ERR, and RTYPE_OK.

                                                                        {
    //std::string roadID;
    //float lanePos;
    //unsigned char laneIndex;
    RoadMapPos roadPos;
    MSLane* actLane;

    // NodeId
    int nodeId = myInputStorage.readInt();
    MSVehicle* veh = getVehicleByExtId(nodeId);   // external node id (equipped vehicle number)

    if (veh == NULL) {
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "Can not retrieve node with given ID");
        return false;
    }

    // StopPosition
    unsigned char posType = myInputStorage.readUnsignedByte();  // position type
    switch (posType) {
    case POSITION_ROADMAP:
        // read road map position
        roadPos.roadId = myInputStorage.readString();
        roadPos.pos = myInputStorage.readFloat();
        roadPos.laneId = myInputStorage.readUnsignedByte();
        break;
    case POSITION_2D:
    case POSITION_3D:
        // convert other position type to road map position
    {
        float x = myInputStorage.readFloat();
        float y = myInputStorage.readFloat();
        roadPos = convertCartesianToRoadMap(Position2D(x,y));
    }
    if (posType == POSITION_3D) {
        myInputStorage.readFloat(); // z value is ignored
    }
    break;
    default:
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "Not supported or unknown Position Format");
        return false;
    }

    // Radius
    float radius = myInputStorage.readFloat();
    // waitTime
    SUMOTime waitTime = myInputStorage.readInt();

    if (roadPos.pos < 0) {
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "Position on lane must not be negative");
        return false;
    }

    // get the actual lane that is referenced by laneIndex
    MSEdge* road = MSEdge::dictionary(roadPos.roadId);
    if (road == NULL) {
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "Unable to retrieve road with given id");
        return false;
    }

    const std::vector<MSLane*> &allLanes = road->getLanes();
    if (roadPos.laneId >= allLanes.size()) {
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "No lane existing with such id on the given road");
        return false;
    }

    actLane = allLanes[0];
    int index = 0;
    while (road->rightLane(actLane) != NULL) {
        actLane = road->rightLane(actLane);
        index++;
    }
    actLane = allLanes[0];
    if (index < roadPos.laneId) {
        for (int i=0; i < (roadPos.laneId - index); i++) {
            actLane = road->leftLane(actLane);
        }
    } else {
        for (int i=0; i < (index - roadPos.laneId); i++) {
            actLane = road->rightLane(actLane);
        }
    }

    // Forward command to vehicle
    if (!veh->addTraciStop(actLane, roadPos.pos, radius, waitTime)) {
        writeStatusCmd(CMD_STOP, RTYPE_ERR, "Vehicle is too close or behind the stop on " + actLane->getID());
        return false;
    }

    // create a reply message
    writeStatusCmd(CMD_STOP, RTYPE_OK, "");
    // add a stopnode command containging the actually used road map position to the reply
    int length = 1 + 1 + 4 + 1 + (4+roadPos.roadId.length()) + 4 + 1 + 4 + 4;
    myOutputStorage.writeUnsignedByte(length);              // lenght
    myOutputStorage.writeUnsignedByte(CMD_STOP);            // command id
    myOutputStorage.writeInt(nodeId);                       // node id
    myOutputStorage.writeUnsignedByte(POSITION_ROADMAP);    // pos format
    myOutputStorage.writeString(roadPos.roadId);                    // road id
    myOutputStorage.writeFloat(roadPos.pos);                    // pos
    myOutputStorage.writeUnsignedByte(roadPos.laneId);          // lane id
    myOutputStorage.writeFloat(radius);                     // radius
    myOutputStorage.writeInt(waitTime);                 // wait time

    return true;
}

bool TraCIServer::commandSubscribeDomain

(

)

throw (TraCIException) [private]

Definition at line 1661 of file TraCIServer.cpp.

References CMD_SUBSCRIBEDOMAIN, DOM_VEHICLE, DOMVAR_ALLOWED_SPEED, DOMVAR_ANGLE, DOMVAR_CO2EMISSION, DOMVAR_COEMISSION, DOMVAR_FUELCONSUMPTION, DOMVAR_HCEMISSION, DOMVAR_NOXEMISSION, DOMVAR_PMXEMISSION, DOMVAR_POSITION, DOMVAR_SIMTIME, DOMVAR_SPEED, POSITION_2D, POSITION_ROADMAP, RTYPE_NOTIMPLEMENTED, RTYPE_OK, TYPE_DOUBLE, and TYPE_FLOAT.

                                                          {
    // domain
    int domainId = myInputStorage.readUnsignedByte();

    if (domainId != DOM_VEHICLE) {
        // send negative command response
        writeStatusCmd(CMD_SUBSCRIBEDOMAIN, RTYPE_NOTIMPLEMENTED, "Can only subscribe to DOM_VEHICLE at this time");
        return false;
    }

    // variable count
    int variableCount = myInputStorage.readUnsignedByte();

    // list of variable ids and types
    std::list<std::pair<int, int> > subscribedVariables;
    for (int i = 0; i < variableCount; i++) {
        // variable id
        int variableId = myInputStorage.readUnsignedByte();

        // value data type
        int dataType = myInputStorage.readUnsignedByte();

        if (!(
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_SIMTIME) && (dataType == TYPE_DOUBLE))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_SPEED) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_ALLOWED_SPEED) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_POSITION) && (dataType == POSITION_2D))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_POSITION) && (dataType == POSITION_ROADMAP))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_ANGLE) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_CO2EMISSION) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_COEMISSION) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_HCEMISSION) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_PMXEMISSION) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_NOXEMISSION) && (dataType == TYPE_FLOAT))
                    ||
                    ((domainId == DOM_VEHICLE) && (variableId == DOMVAR_FUELCONSUMPTION) && (dataType == TYPE_FLOAT))
                )) {
            // send negative command response
            writeStatusCmd(CMD_SUBSCRIBEDOMAIN, RTYPE_NOTIMPLEMENTED, "Can not subscribe to this domain/variable/type combination");
            return false;
        }

        subscribedVariables.push_back(std::pair<int, int>(variableId, dataType));
    }

    // store subscription
    myDomainSubscriptions[domainId] = subscribedVariables;

    // send positive command response
    writeStatusCmd(CMD_SUBSCRIBEDOMAIN, RTYPE_OK, "");
    return true;
}

bool TraCIServer::commandSubscribeLifecycles

(

)

throw (TraCIException) [private]

Definition at line 1611 of file TraCIServer.cpp.

References CMD_SUBSCRIBELIFECYCLES, DOM_VEHICLE, RTYPE_NOTIMPLEMENTED, and RTYPE_OK.

                                                              {
    // domain
    int domain = myInputStorage.readUnsignedByte();

    if (domain != DOM_VEHICLE) {
        // send negative command response
        writeStatusCmd(CMD_SUBSCRIBELIFECYCLES, RTYPE_NOTIMPLEMENTED, "Can only subscribe to lifecycle of DOM_VEHICLE at this time");
        return false;
    }

    myLifecycleSubscriptions.insert(domain);

    if (domain == DOM_VEHICLE) {
        myCreatedVehicles.clear();
        myDestroyedVehicles.clear();
    }

    // send positive command response
    writeStatusCmd(CMD_SUBSCRIBELIFECYCLES, RTYPE_OK, "");
    return true;
}

bool TraCIServer::commandUnsubscribeDomain

(

)

throw (TraCIException) [private]

Definition at line 1727 of file TraCIServer.cpp.

References CMD_UNSUBSCRIBEDOMAIN, DOM_VEHICLE, RTYPE_NOTIMPLEMENTED, and RTYPE_OK.

                                                            {
    // domain
    int domain = myInputStorage.readUnsignedByte();

    if (domain != DOM_VEHICLE) {
        // send negative command response
        writeStatusCmd(CMD_UNSUBSCRIBEDOMAIN, RTYPE_NOTIMPLEMENTED, "Can only subscribe to lifecycle of DOM_VEHICLE at this time");
        return false;
    }

    myDomainSubscriptions.erase(domain);

    // send positive command response
    writeStatusCmd(CMD_UNSUBSCRIBEDOMAIN, RTYPE_OK, "");
    return true;
}

bool TraCIServer::commandUnsubscribeLifecycles

(

)

throw (TraCIException) [private]

Definition at line 1636 of file TraCIServer.cpp.

References CMD_UNSUBSCRIBELIFECYCLES, DOM_VEHICLE, RTYPE_NOTIMPLEMENTED, and RTYPE_OK.

                                                                {
    // domain
    int domain = myInputStorage.readUnsignedByte();

    if (domain != DOM_VEHICLE) {
        // send negative command response
        writeStatusCmd(CMD_UNSUBSCRIBELIFECYCLES, RTYPE_NOTIMPLEMENTED, "Can only subscribe to lifecycle of DOM_VEHICLE at this time");
        return false;
    }

    myLifecycleSubscriptions.erase(domain);

    if (domain == DOM_VEHICLE) {
        myCreatedVehicles.clear();
        myDestroyedVehicles.clear();
    }

    // send positive command response
    writeStatusCmd(CMD_UNSUBSCRIBELIFECYCLES, RTYPE_OK, "");
    return true;
}

bool TraCIServer::commandUpdateCalibrator

(

)

throw (TraCIException) [private]

Definition at line 1242 of file TraCIServer.cpp.

References MSCalibrator::updateCalibrator().

                                                           {
    myOutputStorage.reset();

    int countTime = myInputStorage.readInt();
    int vehicleCount = myInputStorage.readInt();
    std::string calibratorId = myInputStorage.readString();

    MSCalibrator::updateCalibrator(calibratorId, countTime, vehicleCount);

    //@TODO write response according to result of updateCalibrator

    return true;
}

TraCIServer::RoadMapPos TraCIServer::convertCartesianToRoadMap

(

Position2D

pos

)

[private]

Converts a cartesian position to the closest road map position

Parameters:

pos

cartesian position that is to be converted

Returns:

the closest road map position to the cartesian position

Definition at line 1889 of file TraCIServer.cpp.

References GeomHelper::closestDistancePointLine(), MSEdge::dictionary(), Position2D::distanceTo(), MSNet::getEdgeControl(), MSEdgeControl::getEdgeNames(), MSNet::getInstance(), MSEdge::getLanes(), MSLane::getRightLane(), traci::TraCIServer::RoadMapPos::laneId, traci::TraCIServer::RoadMapPos::pos, traci::TraCIServer::RoadMapPos::roadId, Position2DVector::size(), SUMOReal, Position2D::x(), and Position2D::y().

                                                     {
    RoadMapPos result;
    std::vector<std::string> allEdgeIds;
    MSEdge* edge;
    Position2D lineStart;
    Position2D lineEnd;
    double minDistance = HUGE_VAL;
    SUMOReal newDistance;
    Position2D intersection;
    MSLane* tmpLane;


    allEdgeIds = MSNet::getInstance()->getEdgeControl().getEdgeNames();

    // iterate through all known edges
    for (std::vector<std::string>::iterator itId = allEdgeIds.begin(); itId != allEdgeIds.end(); itId++) {
        edge = MSEdge::dictionary((*itId));
        const std::vector<MSLane*> &allLanes = edge->getLanes();

//      cerr << "--------" << endl << "Checking edge " << edge->getID() << endl << "--------" << endl;

        // iterate through all lanes of this edge
        for (std::vector<MSLane*>::const_iterator itLane = allLanes.begin(); itLane != allLanes.end(); itLane++) {
            Position2DVector shape = (*itLane)->getShape();

//          cerr << "### Lane: " << (*itLane)->getID() << endl;

            // iterate through all segments of this lane's shape
            for (int i = 0; i < shape.size()-1; i++) {
                lineStart = shape[i];
                lineEnd = shape[i+1];

//              cerr << "-Segment " << i << "(" << shape[i] << " - " << shape[i+1] << "): ";

                // if this line is no candidate for lying closer to the cartesian position
                // than the line determined so far, skip it
                if ((lineStart.y() > (pos.y()+minDistance) && lineEnd.y() > (pos.y()+minDistance))
                        || (lineStart.y() < (pos.y()-minDistance) && lineEnd.y() < (pos.y()-minDistance))
                        || (lineStart.x() > (pos.x()+minDistance) && lineEnd.x() > (pos.x()+minDistance))
                        || (lineStart.x() < (pos.x()-minDistance) && lineEnd.x() < (pos.x()-minDistance))) {

//                  cerr << "skipping (minDistance = " << minDistance << ")" << endl;

                    continue;
                } else {
                    // else compute the distance and check it
                    newDistance = GeomHelper::closestDistancePointLine(pos, lineStart, lineEnd, intersection);

//                  cerr << "not skipping. ";

                    if (newDistance < minDistance && newDistance != -1.0) {
                        // new distance is shorter: save the found road map position
                        minDistance = newDistance;
                        result.roadId = (*itId);
                        result.laneId = 0;
                        tmpLane = (*itLane);
                        while ((tmpLane =tmpLane->getRightLane()) != NULL) {
                            result.laneId++;
                        }
                        result.pos = lineStart.distanceTo(intersection);
                        for (int j = 0; j < i; j++) {
                            result.pos += shape[j].distanceTo(shape[j+1]);
                        }

//                      cerr << "Saved new pos: " << result.pos << ", intersec at (" << intersection.x() << "," << intersection.y()
//                              << "), minDistance = " << minDistance;
                    }

//                  cerr << endl;
                }
            }
        }
    }

    return result;
}

void TraCIServer::convertExt2IntId	(	int	extId,
		std::string &	intId
	)			[private]

Definition at line 1771 of file TraCIServer.cpp.

                                                         {
    if (isMapChanged_) {
        isMapChanged_ = false;
        ext2intId.clear();
        for (map<std::string, int>::const_iterator iter = equippedVehicles_.begin(); iter != equippedVehicles_.end(); ++iter) {
            if (iter->second > -1) {
                ext2intId[iter->second] = iter->first;
            }
        }
    }

    // Search for external-Id-int and return internal-Id-string
    map<int, std::string>::const_iterator it = ext2intId.find(extId);
    if (it != ext2intId.end()) intId = it->second;
    else intId = "";
}

Position2D TraCIServer::convertRoadMapToCartesian

(

TraCIServer::RoadMapPos

pos

)

throw (TraCIException) [private]

Converts a road map position to a cartesian position

Parameters:

pos

road map position that is to be convertes

Returns:

closest 2D position

Definition at line 1969 of file TraCIServer.cpp.

References MSEdge::dictionary(), MSEdge::getLanes(), and Position2DVector::positionAtLengthPosition().

                      {
    if (roadPos.pos < 0) {
        throw TraCIException("Position on lane must not be negative");
    }

    // get the edge and lane of this road map position
    MSEdge* road = MSEdge::dictionary(roadPos.roadId);
    if (road == NULL) {
        throw TraCIException("Unable to retrieve road with given id");
    }

    const std::vector<MSLane*> &allLanes = road->getLanes();
    if ((roadPos.laneId >= allLanes.size()) || (allLanes.size() == 0)) {
        throw TraCIException("No lane existing with such id on the given road");
    }

    // get corresponding x and y coordinates
    Position2DVector shape = allLanes[roadPos.laneId]->getShape();
    return shape.positionAtLengthPosition(roadPos.pos);
}

int TraCIServer::dispatchCommand

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 339 of file TraCIServer.cpp.

References CMD_ADDVEHICLE, CMD_CHANGELANE, CMD_CHANGEROUTE, CMD_CHANGETARGET, CMD_CLOSE, CMD_DISTANCEREQUEST, CMD_GET_EDGE_VARIABLE, CMD_GET_INDUCTIONLOOP_VARIABLE, CMD_GET_JUNCTION_VARIABLE, CMD_GET_LANE_VARIABLE, CMD_GET_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE, CMD_GET_POI_VARIABLE, CMD_GET_POLYGON_VARIABLE, CMD_GET_ROUTE_VARIABLE, CMD_GET_SIM_VARIABLE, CMD_GET_TL_VARIABLE, CMD_GET_VEHICLE_VARIABLE, CMD_GET_VEHICLETYPE_VARIABLE, CMD_GETALLTLIDS, CMD_GETTLSTATUS, CMD_POSITIONCONVERSION, CMD_SCENARIO, CMD_SET_EDGE_VARIABLE, CMD_SET_LANE_VARIABLE, CMD_SET_POI_VARIABLE, CMD_SET_POLYGON_VARIABLE, CMD_SET_TL_VARIABLE, CMD_SET_VEHICLE_VARIABLE, CMD_SETMAXSPEED, CMD_SIMSTEP, CMD_SIMSTEP2, CMD_SLOWDOWN, CMD_STOP, CMD_SUBSCRIBE_EDGE_VARIABLE, CMD_SUBSCRIBE_INDUCTIONLOOP_VARIABLE, CMD_SUBSCRIBE_JUNCTION_VARIABLE, CMD_SUBSCRIBE_LANE_VARIABLE, CMD_SUBSCRIBE_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE, CMD_SUBSCRIBE_POI_VARIABLE, CMD_SUBSCRIBE_POLYGON_VARIABLE, CMD_SUBSCRIBE_ROUTE_VARIABLE, CMD_SUBSCRIBE_SIM_VARIABLE, CMD_SUBSCRIBE_TL_VARIABLE, CMD_SUBSCRIBE_VEHICLE_VARIABLE, CMD_SUBSCRIBE_VEHICLETYPE_VARIABLE, CMD_SUBSCRIBEDOMAIN, CMD_SUBSCRIBELIFECYCLES, CMD_UNSUBSCRIBEDOMAIN, CMD_UNSUBSCRIBELIFECYCLES, CMD_UPDATECALIBRATOR, DELTA_T, TraCIServerAPI_Simulation::processGet(), TraCIServerAPI_Edge::processGet(), TraCIServerAPI_Junction::processGet(), TraCIServerAPI_Polygon::processGet(), TraCIServerAPI_POI::processGet(), TraCIServerAPI_Route::processGet(), TraCIServerAPI_VehicleType::processGet(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Lane::processGet(), TraCIServerAPI_TLS::processGet(), TraCIServerAPI_MeMeDetector::processGet(), TraCIServerAPI_InductionLoop::processGet(), TraCIServerAPI_Edge::processSet(), TraCIServerAPI_Polygon::processSet(), TraCIServerAPI_POI::processSet(), TraCIServerAPI_Vehicle::processSet(), TraCIServerAPI_Lane::processSet(), TraCIServerAPI_TLS::processSet(), RTYPE_ERR, RTYPE_NOTIMPLEMENTED, and SUMOReal.

                                           {
    int commandStart = myInputStorage.position();
    int commandLength = myInputStorage.readUnsignedByte();
    if (commandLength==0) {
        commandLength = myInputStorage.readInt();
    }

    int commandId = myInputStorage.readUnsignedByte();
    bool success = false;
    // dispatch commands
    switch (commandId) {
    case CMD_SETMAXSPEED:
        success = commandSetMaximumSpeed();
        break;
    case CMD_SIMSTEP:
        success = targetTime_ = static_cast<SUMOTime>(myInputStorage.readInt());
        return commandId;
    case CMD_SIMSTEP2: {
        SUMOTime nextT = myInputStorage.readInt();
        success = true;
        if (nextT!=0) {
            targetTime_ = (SUMOReal) nextT;
        } else {
            targetTime_ += DELTA_T;
        }
        return commandId;
    }
    case CMD_STOP:
        success = commandStopNode();
        break;
    case CMD_CHANGELANE:
        success = commandChangeLane();
        break;
    case CMD_CHANGEROUTE:
        success = commandChangeRoute();
        break;
    case CMD_CHANGETARGET:
        success = commandChangeTarget();
        break;
    case CMD_GETALLTLIDS:
        success = commandGetAllTLIds();
        break;
    case CMD_GETTLSTATUS:
        success = commandGetTLStatus();
        break;
    case CMD_CLOSE:
        success = commandCloseConnection();
        break;
    case CMD_UPDATECALIBRATOR:
        success = commandUpdateCalibrator();
        break;
    case CMD_POSITIONCONVERSION:
        success = commandPositionConversion();
        break;
    case CMD_SLOWDOWN:
        success = commandSlowDown();
        break;
    case CMD_SCENARIO:
        success = commandScenario();
        break;
    case CMD_ADDVEHICLE:
        success = commandAddVehicle();
        break;
    case CMD_DISTANCEREQUEST:
        success = commandDistanceRequest();
        break;
    case CMD_SUBSCRIBELIFECYCLES:
        success = commandSubscribeLifecycles();
        break;
    case CMD_UNSUBSCRIBELIFECYCLES:
        success = commandUnsubscribeLifecycles();
        break;
    case CMD_SUBSCRIBEDOMAIN:
        success = commandSubscribeDomain();
        break;
    case CMD_UNSUBSCRIBEDOMAIN:
        success = commandUnsubscribeDomain();
        break;
    case CMD_GET_INDUCTIONLOOP_VARIABLE:
        success = TraCIServerAPI_InductionLoop::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE:
        success = TraCIServerAPI_MeMeDetector::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_TL_VARIABLE:
        success = TraCIServerAPI_TLS::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_SET_TL_VARIABLE:
        success = TraCIServerAPI_TLS::processSet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_LANE_VARIABLE:
        success = TraCIServerAPI_Lane::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_SET_LANE_VARIABLE:
        success = TraCIServerAPI_Lane::processSet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_VEHICLE_VARIABLE:
        success = TraCIServerAPI_Vehicle::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_SET_VEHICLE_VARIABLE:
        success = TraCIServerAPI_Vehicle::processSet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_VEHICLETYPE_VARIABLE:
        success = TraCIServerAPI_VehicleType::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_ROUTE_VARIABLE:
        success = TraCIServerAPI_Route::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_POI_VARIABLE:
        success = TraCIServerAPI_POI::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_SET_POI_VARIABLE:
        success = TraCIServerAPI_POI::processSet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_POLYGON_VARIABLE:
        success = TraCIServerAPI_Polygon::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_SET_POLYGON_VARIABLE:
        success = TraCIServerAPI_Polygon::processSet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_JUNCTION_VARIABLE:
        success = TraCIServerAPI_Junction::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_EDGE_VARIABLE:
        success = TraCIServerAPI_Edge::processGet(myInputStorage, myOutputStorage);
        break;
    case CMD_SET_EDGE_VARIABLE:
        success = TraCIServerAPI_Edge::processSet(myInputStorage, myOutputStorage);
        break;
    case CMD_GET_SIM_VARIABLE:
        success = TraCIServerAPI_Simulation::processGet(myInputStorage, myOutputStorage, myVehicleStateChanges);
        break;
    case CMD_SUBSCRIBE_INDUCTIONLOOP_VARIABLE:
    case CMD_SUBSCRIBE_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE:
    case CMD_SUBSCRIBE_TL_VARIABLE:
    case CMD_SUBSCRIBE_LANE_VARIABLE:
    case CMD_SUBSCRIBE_VEHICLE_VARIABLE:
    case CMD_SUBSCRIBE_VEHICLETYPE_VARIABLE:
    case CMD_SUBSCRIBE_ROUTE_VARIABLE:
    case CMD_SUBSCRIBE_POI_VARIABLE:
    case CMD_SUBSCRIBE_POLYGON_VARIABLE:
    case CMD_SUBSCRIBE_JUNCTION_VARIABLE:
    case CMD_SUBSCRIBE_EDGE_VARIABLE:
    case CMD_SUBSCRIBE_SIM_VARIABLE:
        success = addSubscription(commandId);
        break;
    default:
        writeStatusCmd(commandId, RTYPE_NOTIMPLEMENTED, "Command not implemented in sumo");
    }
    if (!success) {
        while (myInputStorage.valid_pos() && myInputStorage.position() < commandStart + commandLength) {
            myInputStorage.readChar();
        }
    }
    if (myInputStorage.position() != commandStart + commandLength) {
        ostringstream msg;
        msg << "Wrong position in requestMessage after dispatching command.";
        msg << " Expected command length was " << commandLength;
        msg << " but " << myInputStorage.position() - commandStart << " Bytes were read.";
        writeStatusCmd(commandId, RTYPE_ERR, msg.str());
        closeConnection_ = true;
    }
    return commandId;
}

const Boundary & TraCIServer::getNetBoundary

(

)

[private]

Definition at line 1855 of file TraCIServer.cpp.

References MSNet::getEdgeControl(), MSEdgeControl::getEdges(), and MSNet::getInstance().

                            {
    // If already calculated, just return the boundary
    if (netBoundary_ != NULL) return *netBoundary_;

    // Otherwise calculate it first
    netBoundary_ = new Boundary();
    /*
    {
    // use the junctions to compute the boundaries
    for (size_t index=0; index<myNet.myJunctionWrapper.size(); index++) {
    if (myNet.myJunctionWrapper[index]->getShape().size()>0) {
    ret.add(myNet.myJunctionWrapper[index]->getBoundary());
    } else {
    ret.add(myNet.myJunctionWrapper[index]->getJunction().getPosition());
    }
    }
    }
    */
    // Get all edges
    const std::vector<MSEdge*> &edges = MSNet::getInstance()->getEdgeControl().getEdges();

    // Get Boundary of Single ...
    for (std::vector<MSEdge*>::const_iterator e = edges.begin(); e != edges.end(); ++e) {
        const std::vector<MSLane*> &lanes = (*e)->getLanes();
        for (std::vector<MSLane*>::const_iterator laneIt = lanes.begin(); laneIt != lanes.end(); ++laneIt) {
            netBoundary_->add((*laneIt)->getShape().getBoxBoundary());
        }
    }
    return *netBoundary_;
}

PointOfInterest * TraCIServer::getPoiByExtId

(

int

extId

)

[private]

Definition at line 1813 of file TraCIServer.cpp.

References MSNet::getInstance(), ShapeContainer::getMaxLayer(), ShapeContainer::getMinLayer(), ShapeContainer::getPOICont(), and MSNet::getShapeContainer().

                                    {
    std::string intId = "";
    std::map<int, std::string>::iterator iter = poiExt2IntId.find(extId);
    if (iter != poiExt2IntId.end()) {
        intId = iter->second;
    }

    ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
    PointOfInterest* poi = 0;
    for (int i = shapeCont.getMinLayer(); i <= shapeCont.getMaxLayer(); i++) {
        if (poi == 0) {
            poi = shapeCont.getPOICont(i).get(intId);
        }
    }

    return poi;
}

Polygon2D * TraCIServer::getPolygonByExtId

(

int

extId

)

[private]

Definition at line 1834 of file TraCIServer.cpp.

References MSNet::getInstance(), ShapeContainer::getMaxLayer(), ShapeContainer::getMinLayer(), ShapeContainer::getPolygonCont(), and MSNet::getShapeContainer().

                                        {
    std::string intId = "";
    map<int, std::string>::const_iterator it = ext2intId.find(extId);
    if (it != ext2intId.end()) {
        intId = it->second;
    }

    ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
    Polygon2D* polygon = NULL;
    for (int i = shapeCont.getMinLayer(); i <= shapeCont.getMaxLayer(); i++) {
        if (polygon == NULL) {
            polygon = shapeCont.getPolygonCont(i).get(intId);
        }
    }

    return polygon;
}

MSTrafficLightLogic * TraCIServer::getTLLogicByExtId

(

int

extId

)

[private]

Definition at line 1800 of file TraCIServer.cpp.

References MSTLLogicControl::getActive(), MSNet::getInstance(), and MSNet::getTLSControl().

                                        {
    std::string intId = "";
    std::map<int, std::string>::iterator iter = trafficLightsExt2IntId.find(extId);
    if (iter != trafficLightsExt2IntId.end()) {
        intId = iter->second;
    }

    return MSNet::getInstance()->getTLSControl().getActive(intId);
}

MSVehicle * TraCIServer::getVehicleByExtId

(

int

extId

)

[private]

Definition at line 1791 of file TraCIServer.cpp.

References MSNet::getInstance(), MSVehicleControl::getVehicle(), and MSNet::getVehicleControl().

                                        {
    std::string intId;
    convertExt2IntId(extId, intId);
    return MSNet::getInstance()->getVehicleControl().getVehicle(intId);
}

void traci::TraCIServer::handleDomainSubscriptions	(	const SUMOTime &	currentTime,
		const std::map< int, const MSVehicle * > &	activeEquippedVehicles
	)			throw (TraCIException) [private]

Notifies client of all domain object update events it is subscribed to

void TraCIServer::handleLifecycleSubscriptions

(

)

throw (TraCIException) [private]

Notifies client of all lifecycle events it is subscribed to

Definition at line 2980 of file TraCIServer.cpp.

References CMD_OBJECTCREATION, CMD_OBJECTDESTRUCTION, and DOM_VEHICLE.

                      {

    if (myLifecycleSubscriptions.count(DOM_VEHICLE) != 0) {

        for (std::set<int>::const_iterator i = myDestroyedVehicles.begin(); i != myDestroyedVehicles.end(); i++) {
            int extId = *i;

            myOutputStorage.writeUnsignedByte(1+1+1+4);
            myOutputStorage.writeUnsignedByte(CMD_OBJECTDESTRUCTION);
            myOutputStorage.writeUnsignedByte(DOM_VEHICLE);
            myOutputStorage.writeInt(extId);
        }
        myDestroyedVehicles.clear();

        for (std::set<int>::const_iterator i = myCreatedVehicles.begin(); i != myCreatedVehicles.end(); i++) {
            int extId = *i;

            myOutputStorage.writeUnsignedByte(1+1+1+4);
            myOutputStorage.writeUnsignedByte(CMD_OBJECTCREATION);
            myOutputStorage.writeUnsignedByte(DOM_VEHICLE);
            myOutputStorage.writeInt(extId);
        }
        myCreatedVehicles.clear();

    }
}

std::string TraCIServer::handlePoiDomain	(	bool	isWriteCommand,
		tcpip::Storage &	response
	)			throw (TraCIException) [private]

Handles the request of a Scenario Command for obtaining information on the point of interest domain.

Definition at line 2713 of file TraCIServer.cpp.

References DOM_POI, DOMVAR_COUNT, DOMVAR_EXTID, DOMVAR_LAYER, DOMVAR_NAME, DOMVAR_POSITION, DOMVAR_TYPE, Named::getID(), MSNet::getInstance(), traci::DataTypeContainer::getLastValueRead(), ShapeContainer::getMaxLayer(), ShapeContainer::getMinLayer(), ShapeContainer::getPOICont(), MSNet::getShapeContainer(), traci::DataTypeContainer::getString(), PointOfInterest::getType(), POSITION_3D, traci::DataTypeContainer::readValue(), TYPE_INTEGER, TYPE_STRING, Position2D::x(), and Position2D::y().

                      {
    std::string name;
    std::string warning = "";   // additional description for response
    DataTypeContainer dataCont;

    // domain object
    int objectId = myInputStorage.readInt();
    PointOfInterest* poi = getPoiByExtId(objectId);

    // variable id
    int variableId = myInputStorage.readUnsignedByte();

    // value data type
    int dataType = myInputStorage.readUnsignedByte();

    // if end of message is not yet reached, the value parameter has to be read
    if (myInputStorage.valid_pos()) {
        dataCont.readValue(dataType, myInputStorage);
    }

    if (isWriteCommand) {
        throw TraCIException("Point of interest domain does not contain writable variables");
    }

    // write beginning of the answer message
    response.writeUnsignedByte((isWriteCommand ? 0x01 : 0x00)); // get/set flag
    response.writeUnsignedByte(DOM_POI);    // domain
    response.writeInt(objectId);    // domain object id
    response.writeUnsignedByte(variableId);     // variable

    // get list of shapes and determine total number of poi
    int count = 0;
    ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
    for (int i = shapeCont.getMinLayer(); i <= shapeCont.getMaxLayer(); i++) {
        count += shapeCont.getPOICont(i).size();
    }

    switch (variableId) {
        // name std::string of the object
    case DOMVAR_NAME:
        if (poi != NULL) {
            name = poi->getID();
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(name);
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_STRING) {
                warning = "Warning: requested data type could not be used; using string instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve point of interest with given id");
        }
        break;

        // external id of the object
    case DOMVAR_EXTID:
//      if (dataType != TYPE_STRING) {
        if (dataCont.getLastValueRead() != TYPE_STRING) {
            throw TraCIException("Internal id must be given as string value");
        }
//      name = myInputStorage.readString();
        name = dataCont.getString();
        if (poiInt2ExtId.find(name) != poiInt2ExtId.end()) {
            response.writeUnsignedByte(TYPE_INTEGER);
            response.writeInt(poiInt2ExtId[name]);
        } else {
            std::stringstream msg;
            msg << "Point of interest with internal id " << name << " not existing";
            throw TraCIException(msg.str());
        }
        break;

        // number of poi
    case DOMVAR_COUNT:
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(count);
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // position of a poi
    case DOMVAR_POSITION:
        if (poi == NULL) {
            throw TraCIException("Unable to retrieve point of interest with given id");
        } else {
            response.writeUnsignedByte(POSITION_3D);
            response.writeFloat(poi->x());
            response.writeFloat(poi->y());
            response.writeFloat(0);
        }
        // add a warning to the response if the requested data type was not correct
        if (dataType != POSITION_3D) {
            warning = "Warning: requested data type could not be used; using 3D position instead!";
        }
        break;

        // type of a poi
    case DOMVAR_TYPE:
        if (poi == NULL) {
            throw TraCIException("Unable to retrieve point of interest with given id");
        } else {
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(poi->getType());
        }
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_STRING) {
            warning = "Warning: requested data type could not be used; using string instead!";
        }
        break;

        // layer of a poi
    case DOMVAR_LAYER:
        // unknown variable
    default:
        throw TraCIException("Unknown domain variable specified");
    }

    return warning;
}

std::string TraCIServer::handlePolygonDomain	(	bool	isWriteCommand,
		tcpip::Storage &	response
	)			throw (TraCIException) [private]

Handles the request of a Scenario Command for obtaining information on the polygon domain.

Definition at line 2838 of file TraCIServer.cpp.

References DOM_POLYGON, DOMVAR_COUNT, DOMVAR_EXTID, DOMVAR_LAYER, DOMVAR_NAME, DOMVAR_POSITION, DOMVAR_SHAPE, DOMVAR_TYPE, Polygon2D::getID(), MSNet::getInstance(), traci::DataTypeContainer::getLastValueRead(), ShapeContainer::getMaxLayer(), ShapeContainer::getMinLayer(), Position2DVector::getPolygonCenter(), ShapeContainer::getPolygonCont(), Polygon2D::getShape(), MSNet::getShapeContainer(), traci::DataTypeContainer::getString(), Polygon2D::getType(), MIN2(), POSITION_3D, traci::DataTypeContainer::readValue(), Position2DVector::size(), TYPE_INTEGER, TYPE_POLYGON, TYPE_STRING, Position2D::x(), and Position2D::y().

                      {
    std::string name;
    std::string warning = "";   // additional description for response
    DataTypeContainer dataCont;

    // domain object
    int objectId = myInputStorage.readInt();
    Polygon2D* poly = getPolygonByExtId(objectId);

    // variable id
    int variableId = myInputStorage.readUnsignedByte();

    // value data type
    int dataType = myInputStorage.readUnsignedByte();

    // if end of message is not yet reached, the value parameter has to be read
    if (myInputStorage.valid_pos()) {
        dataCont.readValue(dataType, myInputStorage);
    }

    if (isWriteCommand) {
        throw TraCIException("Polygon domain does not contain writable variables");
    }

    // write beginning of the answer message
    response.writeUnsignedByte((isWriteCommand ? 0x01 : 0x00)); // get/set flag
    response.writeUnsignedByte(DOM_POLYGON);    // domain
    response.writeInt(objectId);    // domain object id
    response.writeUnsignedByte(variableId);     // variable

    // get list of shapes and determine total number of polygons
    int count = 0;
    ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
    for (int i = shapeCont.getMinLayer(); i <= shapeCont.getMaxLayer(); i++) {
        count += shapeCont.getPolygonCont(i).size();
    }

    switch (variableId) {
        // name std::string of the object
    case DOMVAR_NAME:
        if (poly != NULL) {
            name = poly->getID();
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(name);
            if (dataType != TYPE_STRING) {
                warning = "Warning: requested data type could not be used; using string instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve polygon with given id");
        }
        break;

        // external id of the object
    case DOMVAR_EXTID:
//      if (dataType != TYPE_STRING) {
        if (dataCont.getLastValueRead() != TYPE_STRING) {
            throw TraCIException("Internal id must be given as string value");
        }
//      name = myInputStorage.readString();
        name = dataCont.getString();
        if (polygonInt2ExtId.find(name) != polygonInt2ExtId.end()) {
            response.writeUnsignedByte(TYPE_INTEGER);
            response.writeInt(polygonInt2ExtId[name]);
        } else {
            std::stringstream msg;
            msg << "Polygon with internal id " << name << " not existing";
            throw TraCIException(msg.str());
        }
        break;

        // number of polygons
    case DOMVAR_COUNT:
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(count);
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // position of a polygon
    case DOMVAR_POSITION:
        if (poly == NULL) {
            throw TraCIException("Unable to retrieve polygon with given id");
        } else {
            response.writeUnsignedByte(POSITION_3D);
            response.writeFloat(poly->getShape().getPolygonCenter().x());
            response.writeFloat(poly->getShape().getPolygonCenter().y());
            response.writeFloat(0);
        }
        // add a warning to the response if the requested data type was not correct
        if (dataType != POSITION_3D) {
            warning = "Warning: requested data type could not be used; using 3D position instead!";
        }
        break;

        // type of a polygon
    case DOMVAR_TYPE:
        if (poly == NULL) {
            throw TraCIException("Unable to retrieve polygon with given id");
        } else {
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(poly->getType());
        }
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_STRING) {
            warning = "Warning: requested data type could not be used; using string instead!";
        }
        break;

        // shape of a polygon
    case DOMVAR_SHAPE:
        if (poly == NULL) {
            throw TraCIException("Unable to retrieve polygon with given id");
        } else {
            response.writeUnsignedByte(TYPE_POLYGON);
            response.writeUnsignedByte(MIN2(static_cast<size_t>(255),poly->getShape().size()));
            for (int i=0; i < MIN2(static_cast<size_t>(255),poly->getShape().size()); i++) {
                response.writeFloat(poly->getShape()[i].x());
                response.writeFloat(poly->getShape()[i].y());
            }
        }
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_POLYGON) {
            warning = "Warning: requested data type could not be used; using polygon type instead!";
        }
        break;

        // layer of a polygon
    case DOMVAR_LAYER:
        // unknown variable
    default:
        throw TraCIException("Unknown domain variable specified");
    }

    return warning;
}

std::string TraCIServer::handleRoadMapDomain	(	bool	isWriteCommand,
		tcpip::Storage &	response
	)			throw (TraCIException) [private]

Handles the request of a Scenario Command for obtaining information on the road map domain.

Parameters:

	requestMsg	original Scenario command message, the fields flag and domain have already been read
	response	storage object that will contain the variable dependant part of the response on this request
	isWriteCommand	true, if the command wants to write a value

Returns:

string containing an optional warning (to be added to the response command) if the requested variable type could not be used

Definition at line 1994 of file TraCIServer.cpp.

References MSEdge::dictionary(), MSEdge::dictSize(), DOM_ROADMAP, DOMVAR_BOUNDINGBOX, DOMVAR_COUNT, DOMVAR_EXTID, DOMVAR_NAME, DOMVAR_SHAPE, MSEdge::getID(), MSNet::getInstance(), MSEdge::getLanes(), traci::DataTypeContainer::getLastValueRead(), MSEdge::getNumericalID(), traci::DataTypeContainer::getString(), MIN2(), traci::DataTypeContainer::readValue(), Position2DVector::size(), size, TYPE_BOUNDINGBOX, TYPE_INTEGER, TYPE_POLYGON, and TYPE_STRING.

                      {
    std::string name = "";
    std::string warning = "";   // additional description for response
    DataTypeContainer dataCont;

    // domain object
    int objectId = myInputStorage.readInt();
    // check for valid object id
    if (objectId < 0 || objectId >= MSEdge::dictSize()) {
        throw TraCIException("Invalid object id specified");
    }
    MSEdge* edge = MSEdge::dictionary(objectId);

    // variable id
    int variableId = myInputStorage.readUnsignedByte();

    // value data type
    int dataType = myInputStorage.readUnsignedByte();

    // if end of message is not yet reached, the value parameter has to be read
    if (myInputStorage.valid_pos()) {
        dataCont.readValue(dataType, myInputStorage);
    }

    if (isWriteCommand) {
        throw TraCIException("Road map domain does not contain writable variables");
    }

    // write beginning of the answer message
    response.writeUnsignedByte((isWriteCommand ? 0x01 : 0x00)); // get/set flag
    response.writeUnsignedByte(DOM_ROADMAP);    // domain
    response.writeInt(objectId);    // domain object id
    response.writeUnsignedByte(variableId);     // variable

    switch (variableId) {
        // name std::string of the object
    case DOMVAR_NAME:
        if (edge != NULL) {
            name = edge->getID();
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(name);
            if (dataType != TYPE_STRING) {
                warning = "Warning: requested data type could not be used; using string instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve road with given id");
        }
        break;

        // numerical id of an edge
    case DOMVAR_EXTID:
        //if (dataType != TYPE_STRING) {
        if (dataCont.getLastValueRead() != TYPE_STRING) {
            throw TraCIException("Internal id must be given as string value");
        }
        //name = myInputStorage.readString();
        name = dataCont.getString();
        edge = MSEdge::dictionary(name);
        if (edge != NULL) {
            response.writeUnsignedByte(TYPE_INTEGER);
            response.writeInt(edge->getNumericalID());
        } else {
            std::stringstream msg;
            msg << "Edge with internal id " << name << " not existing";
            throw TraCIException(msg.str());
        }
        break;

        // net boundaries
    case DOMVAR_BOUNDINGBOX:
        response.writeUnsignedByte(TYPE_BOUNDINGBOX);
        response.writeFloat(getNetBoundary().xmin());
        response.writeFloat(getNetBoundary().ymin());
        response.writeFloat(getNetBoundary().xmax());
        response.writeFloat(getNetBoundary().ymax());
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_BOUNDINGBOX) {
            warning = "Warning: requested data type could not be used; using boundary box type instead!";
        }
        break;

        // number of roads
    case DOMVAR_COUNT:
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(MSNet::getInstance()->getEdgeControl().getEdgeNames().size());
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // shape of a road
    case DOMVAR_SHAPE:
        if (edge != NULL) {
            const std::vector<MSLane*> &lanes = edge->getLanes();
            const Position2DVector shape = lanes[lanes.size()/2]->getShape();
            response.writeUnsignedByte(TYPE_POLYGON);
            response.writeUnsignedByte(MIN2(static_cast<size_t>(255),shape.size()));
            for (int iPoint=0; iPoint < MIN2(static_cast<size_t>(255),shape.size()); iPoint++) {
                response.writeFloat(shape[iPoint].x());
                response.writeFloat(shape[iPoint].y());
            }
            if (dataType != TYPE_POLYGON) {
                warning = "Warning: requested data type could not be used; using polygon type instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve road with given id");
        }
        break;

        // unknown variable
    default:
        throw TraCIException("Unknown domain variable specified");
    }

    return warning;
}

std::string TraCIServer::handleTrafficLightDomain	(	bool	isWriteCommand,
		tcpip::Storage &	response
	)			throw (TraCIException) [private]

Handles the request of a Scenario Command for obtaining information on the traffic light domain.

Definition at line 2491 of file TraCIServer.cpp.

References DOM_TRAFFICLIGHTS, DOMVAR_COUNT, DOMVAR_CURTLPHASE, DOMVAR_EXTID, DOMVAR_NAME, DOMVAR_NEXTTLPHASE, DOMVAR_POSITION, NamedObjectCont< T >::get(), MSTLLogicControl::getAllTLIds(), MSTrafficLightLogic::getCurrentPhaseIndex(), MSEdge::getID(), MSTrafficLightLogic::getID(), MSTrafficLightLogic::getIndexFromOffset(), MSNet::getInstance(), MSNet::getJunctionControl(), MSTrafficLightLogic::getLanesAt(), traci::DataTypeContainer::getLastValueRead(), MSTrafficLightLogic::getLinks(), MSTrafficLightLogic::getPhase(), MSTrafficLightLogic::getPhaseIndexAtTime(), MSJunction::getPosition(), MSPhaseDefinition::getSignalState(), traci::DataTypeContainer::getString(), MSNet::getTLSControl(), MSLink::LINKSTATE_TL_GREEN_MAJOR, MSLink::LINKSTATE_TL_GREEN_MINOR, MSLink::LINKSTATE_TL_OFF_BLINKING, MSLink::LINKSTATE_TL_OFF_NOSIGNAL, MSLink::LINKSTATE_TL_RED, MSLink::LINKSTATE_TL_YELLOW_MAJOR, MSLink::LINKSTATE_TL_YELLOW_MINOR, POSITION_3D, traci::DataTypeContainer::readValue(), TLPHASE_BLINKING, TLPHASE_GREEN, TLPHASE_NOSIGNAL, TLPHASE_RED, TLPHASE_YELLOW, TYPE_INTEGER, TYPE_STRING, TYPE_TLPHASELIST, tcpip::Storage::writeString(), tcpip::Storage::writeUnsignedByte(), Position2D::x(), and Position2D::y().

                      {
    int count = 0;
    std::string name;
    std::string warning = "";   // additional description for response
    DataTypeContainer dataCont;

    // domain object
    int objectId = myInputStorage.readInt();
    MSTrafficLightLogic* tlLogic = getTLLogicByExtId(objectId);

    // variable id
    int variableId = myInputStorage.readUnsignedByte();

    // value data type
    int dataType = myInputStorage.readUnsignedByte();

    // if end of message is not yet reached, the value parameter has to be read
    if (myInputStorage.valid_pos()) {
        dataCont.readValue(dataType, myInputStorage);
    }

    if (isWriteCommand) {
        throw TraCIException("Traffic Light domain does not contain writable variables");
    }

    // write beginning of the answer message
    response.writeUnsignedByte((isWriteCommand ? 0x01 : 0x00)); // get/set flag
    response.writeUnsignedByte(DOM_TRAFFICLIGHTS);  // domain
    response.writeInt(objectId);    // domain object id
    response.writeUnsignedByte(variableId);     // variable

    switch (variableId) {
        // name std::string of the object
    case DOMVAR_NAME:
        if (tlLogic != NULL) {
            name = tlLogic->getID();
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(name);
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_STRING) {
                warning = "Warning: requested data type could not be used; using string instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve traffic light with given id");
        }
        break;

        // external id of the object
    case DOMVAR_EXTID:
//      if (dataType != TYPE_STRING) {
        if (dataCont.getLastValueRead() != TYPE_STRING) {
            throw TraCIException("Internal id must be given as string value");
        }
//      name = myInputStorage.readString();
        name = dataCont.getString();
        if (trafficLightsInt2ExtId.find(name) != trafficLightsInt2ExtId.end()) {
            response.writeUnsignedByte(TYPE_INTEGER);
            response.writeInt(trafficLightsInt2ExtId[name]);
        } else {
            std::stringstream msg;
            msg << "Traffic Light with internal id " << name << " not existing";
            throw TraCIException(msg.str());
        }
        break;

        // count of traffic lights
    case DOMVAR_COUNT:
        count = MSNet::getInstance()->getTLSControl().getAllTLIds().size();
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(count);
        // add a warning to the response if the requested data type was not correct
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // position of a traffic light
    case DOMVAR_POSITION:
        if (tlLogic != NULL) {
            MSJunction* junc = MSNet::getInstance()->getJunctionControl().get(tlLogic->getID());
            response.writeUnsignedByte(POSITION_3D);
            response.writeFloat(junc->getPosition().x());
            response.writeFloat(junc->getPosition().y());
            response.writeFloat(0);
            // add a warning to the response if the requested data type was not correct
            if (dataType != POSITION_3D) {
                warning = "Warning: requested data type could not be used; using position 3d instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve traffic light with given id");
        }
        break;

        // current or next traffic light phase
    case DOMVAR_CURTLPHASE:
    case DOMVAR_NEXTTLPHASE:
        if (tlLogic != NULL) {
            // get the required phase of the tl logic
            size_t step = tlLogic->getCurrentPhaseIndex();
            if (variableId == DOMVAR_NEXTTLPHASE) {
                size_t curStep = tlLogic->getCurrentPhaseIndex();
                size_t pos = tlLogic->getPhaseIndexAtTime(MSNet::getInstance()->getCurrentTimeStep());
                do {
                    pos++;
                } while ((step=tlLogic->getIndexFromOffset(pos)) == curStep);
            }
            MSPhaseDefinition phase = tlLogic->getPhase(step);

            // get the list of link vectors affected by that tl logic
            MSTrafficLightLogic::LinkVectorVector affectedLinks = tlLogic->getLinks();

            // for each affected link of that tl logic, write the  phase state
            // to the answer message along with preceding and succeeding edge
            Storage phaseList;
            int listLength = 0;
//          std::map<MSLane*, std::set<const MSEdge*> > connectLane2Edge;
            std::map<const MSEdge*, pair<const MSEdge*, int> > writtenEdgePairs;
            for (int i=0; i<affectedLinks.size(); i++) {
                // get the list of links controlled by that light
                MSTrafficLightLogic::LinkVector linkGroup = affectedLinks[i];
                // get the list of preceding lanes to that links
                MSTrafficLightLogic::LaneVector laneGroup = tlLogic->getLanesAt(i);
                // get status of the traffic light
                MSLink::LinkState tlState = phase.getSignalState(i);

//              const MSEdge* precEdge = NULL;
//              const MSEdge* succEdge = NULL;
                for (int linkNo=0; linkNo<linkGroup.size(); linkNo++) {
                    // if multiple lanes of different edges lead to the same lane on another edge,
                    // only write such pair of edges once
                    /*                  if ((precEdge == laneGroup[linkNo]->getEdge())
                                            && (succEdge == linkGroup[linkNo]->getLane()->getEdge())) {
                                            continue;
                                        }
                                        // remember preceding and succeeding edge
                                        precEdge = laneGroup[linkNo]->getEdge();
                                        succEdge = linkGroup[linkNo]->getLane()->getEdge();

                                        // if the current ingoing lane was part of a connection before...
                                        std::map<MSLane*, std::set<const MSEdge*> >::iterator itMap = connectLane2Edge.find(laneGroup[linkNo]);
                                        if (itMap != connectLane2Edge.end()) {
                                            // ...and the succeding edge of this connection is the same as before...
                                            std::set<const MSEdge*>::iterator itEdge = itMap->second.find(succEdge);
                                            if (itEdge != itMap->second.end()) {
                                                // ...then the connection's phase doesn't need to be reported again
                                                continue;
                                            }
                                        }
                                        // remember the edge that this lane leads to
                                        connectLane2Edge[laneGroup[linkNo]].insert(succEdge);
                    */
                    MSEdge &precEdge = laneGroup[linkNo]->getEdge();
                    MSEdge &succEdge = linkGroup[linkNo]->getLane()->getEdge();

                    // for each pair of edges and every different tl state, write only one tl switch command
                    std::map<const MSEdge*, pair<const MSEdge*, int> >::iterator itPair = writtenEdgePairs.find(&precEdge);
                    if (itPair != writtenEdgePairs.end()) {
                        if (itPair->second.first == &succEdge && itPair->second.second == tlState) {
                            continue;
                        }
                    }
                    // remember the current edge pair and tl status
                    writtenEdgePairs[&precEdge] = std::make_pair(&succEdge, tlState);

                    // write preceding edge
                    phaseList.writeString(precEdge.getID());
                    // write succeeding edge
                    phaseList.writeString(succEdge.getID());
                    // write status of the traffic light
                    switch (tlState) {
                    case MSLink::LINKSTATE_TL_GREEN_MAJOR:
                    case MSLink::LINKSTATE_TL_GREEN_MINOR:
                        phaseList.writeUnsignedByte(TLPHASE_GREEN);
                        break;
                    case MSLink::LINKSTATE_TL_YELLOW_MAJOR:
                    case MSLink::LINKSTATE_TL_YELLOW_MINOR:
                        phaseList.writeUnsignedByte(TLPHASE_YELLOW);
                        break;
                    case MSLink::LINKSTATE_TL_RED:
                        phaseList.writeUnsignedByte(TLPHASE_RED);
                        break;
                    case MSLink::LINKSTATE_TL_OFF_BLINKING:
                        phaseList.writeUnsignedByte(TLPHASE_BLINKING);
                        break;
                    case MSLink::LINKSTATE_TL_OFF_NOSIGNAL:
                        phaseList.writeUnsignedByte(TLPHASE_NOSIGNAL);
                        break;
                    default:
                        phaseList.writeUnsignedByte(TLPHASE_NOSIGNAL);
                    }
                    // increase length of the phase list
                    listLength++;
                }
            }
            //write data type to answer message
            response.writeUnsignedByte(TYPE_TLPHASELIST);
            // write length of the phase list to answer message
            response.writeUnsignedByte(listLength);
            // write list of phases to answer message
            response.writeStorage(phaseList);

            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_TLPHASELIST) {
                warning = "Warning: requested data type could not be used; using type traffic light phase list instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve traffic light with given id");
        }
        break;

        // unknown variable
    default:
        throw TraCIException("Unknown domain variable specified");
    }

    return warning;
}

std::string TraCIServer::handleVehicleDomain	(	bool	isWriteCommand,
		tcpip::Storage &	response
	)			throw (TraCIException) [private]

Handles the request of a Scenario Command for obtaining information on the vehicle domain.

Definition at line 2115 of file TraCIServer.cpp.

References MSRoute::begin(), HelpersHBEFA::computeCO(), HelpersHBEFA::computeCO2(), HelpersHBEFA::computeFuel(), HelpersHBEFA::computeHC(), HelpersHarmonoise::computeNoise(), HelpersHBEFA::computeNOx(), HelpersHBEFA::computePMx(), MSEdge::dictionary(), Position2D::distanceTo(), DOM_VEHICLE, DOMVAR_AIRDISTANCE, DOMVAR_ALLOWED_SPEED, DOMVAR_CO2EMISSION, DOMVAR_COEMISSION, DOMVAR_COUNT, DOMVAR_DRIVINGDISTANCE, DOMVAR_EQUIPPEDCOUNT, DOMVAR_EQUIPPEDCOUNTMAX, DOMVAR_EXTID, DOMVAR_FUELCONSUMPTION, DOMVAR_HCEMISSION, DOMVAR_MAXCOUNT, DOMVAR_NAME, DOMVAR_NOISEEMISSION, DOMVAR_NOXEMISSION, DOMVAR_PMXEMISSION, DOMVAR_POSITION, DOMVAR_ROUTE, DOMVAR_SPEED, MSRoute::end(), traci::DataTypeContainer::getAnyPosition(), MSVehicle::getDistanceToPosition(), MSVehicle::getEdge(), MSVehicleType::getEmissionClass(), MSEdge::getID(), MSVehicle::getID(), MSNet::getInstance(), MSVehicle::getLane(), traci::DataTypeContainer::getLastValueRead(), MSLane::getMaxSpeed(), MSVehicle::getPosition(), MSVehicle::getPositionOnLane(), MSVehicle::getPreDawdleAcceleration(), MSLane::getRightLane(), traci::DataTypeContainer::getRoadMapPosition(), MSVehicle::getRoute(), MSVehicle::getSpeed(), traci::DataTypeContainer::getString(), MSVehicleControl::getVehicle(), MSNet::getVehicleControl(), MSVehicle::getVehicleType(), MSVehicle::isOnRoad(), MSVehicleControl::loadedVehBegin(), MSVehicleControl::loadedVehEnd(), traci::TraCIServer::RoadMapPos::pos, POSITION_2_5D, POSITION_2D, POSITION_3D, POSITION_ROADMAP, traci::DataTypeContainer::readValue(), traci::TraCIServer::RoadMapPos::roadId, TYPE_FLOAT, TYPE_INTEGER, TYPE_STRING, Position2D::x(), and Position2D::y().

                      {
    std::string name;
    int count = 0;
    MSVehicleControl* vehControl = NULL;
    std::string warning = "";   // additional description for response
    DataTypeContainer dataCont;

    // domain object
    int objectId = myInputStorage.readInt();
    MSVehicle* veh = getVehicleByExtId(objectId);   //get node by id

    // variable id
    int variableId = myInputStorage.readUnsignedByte();

    // value data type
    int dataType = myInputStorage.readUnsignedByte();

    // if end of message is not yet reached, the value parameter has to be read
    if (myInputStorage.valid_pos()) {
        dataCont.readValue(dataType, myInputStorage);
    }

    if (isWriteCommand) {
        throw TraCIException("Vehicle domain does not contain writable variables");
    }

    // write beginning of the answer message
    response.writeUnsignedByte((isWriteCommand ? 0x01 : 0x00)); // get/set flag
    response.writeUnsignedByte(DOM_VEHICLE);    // domain
    response.writeInt(objectId);    // domain object id
    response.writeUnsignedByte(variableId);     // variable

    switch (variableId) {
        // name std::string of the object
    case DOMVAR_NAME:
        if (veh != NULL) {
            name = veh->getID();
            response.writeUnsignedByte(TYPE_STRING);
            response.writeString(name);
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_STRING) {
                warning = "Warning: requested data type could not be used; using string instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // external id of the object
    case DOMVAR_EXTID:
//      if (dataType != TYPE_STRING) {
        if (dataCont.getLastValueRead() != TYPE_STRING) {
            throw TraCIException("Internal id must be given as string value");
        }
//      name = myInputStorage.readString();
        name = dataCont.getString();
        if (equippedVehicles_.find(name) != equippedVehicles_.end()) {
            response.writeUnsignedByte(TYPE_INTEGER);
            response.writeInt(equippedVehicles_[name]);
        } else {
            std::stringstream msg;
            msg << "Vehicle with internal id " << name << " not existing or not accessible via TraCI";
            throw TraCIException(msg.str());
        }
        break;

        // number of active nodes
    case DOMVAR_COUNT:
        vehControl = &MSNet::getInstance()->getVehicleControl();
        for (MSVehicleControl::constVehIt vehIt = vehControl->loadedVehBegin(); vehIt != vehControl->loadedVehEnd(); vehIt++) {
            if (vehIt->second->isOnRoad()) {
                count++;
            }
        }
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(count);
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // upper bound for number of nodes
    case DOMVAR_MAXCOUNT:
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(totalNumVehicles_);
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // number of active nodes accesible via traci
    case DOMVAR_EQUIPPEDCOUNT:
        for (std::map<std::string, int>::iterator it=equippedVehicles_.begin(); it != equippedVehicles_.end(); it++) {
            MSVehicle* veh = MSNet::getInstance()->getVehicleControl().getVehicle(it->first);
            if (veh->isOnRoad()) {
                count++;
            }
        }
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(count);
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // upper bound for number of nodes accesible via traci
    case DOMVAR_EQUIPPEDCOUNTMAX:
        response.writeUnsignedByte(TYPE_INTEGER);
        response.writeInt(static_cast<int>(0.5 + totalNumVehicles_ * penetration_));
        if (dataType != TYPE_INTEGER) {
            warning = "Warning: requested data type could not be used; using integer instead!";
        }
        break;

        // node position
    case DOMVAR_POSITION:
        if (veh != NULL) {
            switch (dataType) {
            case POSITION_3D:
                response.writeUnsignedByte(POSITION_3D);
                response.writeFloat(veh->getPosition().x());
                response.writeFloat(veh->getPosition().y());
                response.writeFloat(0);
                break;
            default:
                response.writeByte(POSITION_ROADMAP);
                response.writeString(veh->getEdge()->getID());
                response.writeFloat(veh->getPositionOnLane());
                int laneId = 0;
                MSLane* lane = veh->getLane().getRightLane();
                while (lane != NULL) {
                    laneId++;
                    lane =lane->getRightLane();
                }
                response.writeUnsignedByte(laneId);
                // add a warning to the response if the requested data type was not correct
                if (dataType != POSITION_ROADMAP) {
                    warning = "Warning: requested data type could not be used; using road map position instead!";
                }
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // node speed
    case DOMVAR_SPEED:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(veh->getSpeed());
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // node maximum allowed speed
    case DOMVAR_ALLOWED_SPEED:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(veh->getLane().getMaxSpeed());
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // node route
    case DOMVAR_ROUTE:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_STRING);
            MSRoute r = veh->getRoute();
            std::string strRoute = "";
            for (MSRouteIterator it = r.begin(); it != r.end(); ++it) {
                if (strRoute.length()) strRoute.append(" ");
                strRoute.append((*it)->getID());
            }
            response.writeString(strRoute);
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_STRING) {
                warning = "Warning: requested data type could not be used; using string instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // air distance from vehicle to a point
    case DOMVAR_AIRDISTANCE:
        // driving distance from vehicle to a point
    case DOMVAR_DRIVINGDISTANCE:
        if (veh != NULL) {
            Position2D destPos;
            RoadMapPos destRoadPos;
            float distance = 0.0;

            // read destinatin position
            float x,y;
            switch (dataCont.getLastValueRead()) {
            case POSITION_ROADMAP:
                destRoadPos = dataCont.getRoadMapPosition();
                destPos = convertRoadMapToCartesian(destRoadPos);
                if (MSEdge::dictionary(destRoadPos.roadId) == NULL) throw TraCIException("Unable to retrieve edge with given id");
                break;
            case POSITION_3D:
            case POSITION_2_5D:
            case POSITION_2D:
                destPos = dataCont.getAnyPosition();
                destRoadPos = convertCartesianToRoadMap(destPos);
                break;
            default:
                throw TraCIException("Distance request to unknown destination");
            }

//            switch (dataType)
//            {
//            case POSITION_ROADMAP:
//                {
//                    destEdge = myInputStorage.readString();
//                    destPos = myInputStorage.readFloat();
//                    destLane = myInputStorage.readUnsignedByte();
//                    edge = MSEdge::dictionary( destEdge );
//                    if (edge == NULL ) throw TraCIException("Unable to retrieve edge with given id");
//
//                  const std::vector<MSLane*>& lanes = edge->getLanes();
//                  if (destLane > lanes.size()-1) throw TraCIException("No lane existing with specified id on this edge");
//                    pos = lanes[destLane]->getShape().positionAtLengthPosition(destPos);
//                }
//                break;
//            case POSITION_2D:
//            case POSITION_2_5D:
//            case POSITION_3D:
//                {
//                    float destX = myInputStorage.readFloat();
//                    float destY = myInputStorage.readFloat();
//                  if ((dataType == POSITION_3D) || (dataType == POSITION_2_5D)) {
//                      myInputStorage.readFloat(); // z value is ignored
//                  }
//                  pos.set(destX, destY);
//
//                  RoadMapPos roadPos = convertCartesianToRoadMap(pos);
//                  destEdge = roadPos.roadId;
//                  destPos = roadPos.pos;
//                  destLane = roadPos.laneId;
//                  edge = MSEdge::dictionary( destEdge );
//                }
//                break;
//            default:
//                throw TraCIException("Distance request to unknown destination");
//            }

            // compute the distance to destination position
            if (variableId == DOMVAR_AIRDISTANCE) {
                distance = static_cast<float>(veh->getPosition().distanceTo(destPos));
            } else {
                distance = static_cast<float>(veh->getDistanceToPosition(destRoadPos.pos, MSEdge::dictionary(destRoadPos.roadId)));
            }
            // write response
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(distance);
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // CO2 emission
    case DOMVAR_CO2EMISSION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHBEFA::computeCO2(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;
        // CO emission
    case DOMVAR_COEMISSION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHBEFA::computeCO(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;
        // HC emission
    case DOMVAR_HCEMISSION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHBEFA::computeHC(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;
        // PMx emission
    case DOMVAR_PMXEMISSION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHBEFA::computePMx(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;
        // NOx emission
    case DOMVAR_NOXEMISSION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHBEFA::computeNOx(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;
        // CO2 emission
    case DOMVAR_FUELCONSUMPTION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHBEFA::computeFuel(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;
        // noise emission
    case DOMVAR_NOISEEMISSION:
        if (veh != NULL) {
            response.writeUnsignedByte(TYPE_FLOAT);
            response.writeFloat(HelpersHarmonoise::computeNoise(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getPreDawdleAcceleration()));
            // add a warning to the response if the requested data type was not correct
            if (dataType != TYPE_FLOAT) {
                warning = "Warning: requested data type could not be used; using float instead!";
            }
        } else {
            throw TraCIException("Unable to retrieve node with given ID");
        }
        break;

        // unknown variable
    default:
        throw TraCIException("Unknown domain variable specified");
    }

    return warning;
}

void TraCIServer::postProcessSimulationStep

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 532 of file TraCIServer.cpp.

References CMD_MOVENODE, CMD_SIMSTEP, MSEdge::dictSize(), DOM_VEHICLE, MSEdge::EDGEFUNCTION_INTERNAL, MSVehicle::getEdge(), MSLane::getEdge(), MSEdge::getID(), MSNet::getInstance(), MSVehicle::getLane(), MSVehicle::getPosition(), MSVehicle::getPositionOnLane(), MSEdge::getPurpose(), MSLane::getRightLane(), MSNet::EdgeWeightsProxi::getTravelTime(), MSVehicleControl::getVehicle(), MSNet::getVehicleControl(), MSNet::getWeightsStorage(), MSVehicle::getWeightsStorage(), MSVehicle::hasStops(), MSVehicle::isOnRoad(), MSVehicleControl::loadedVehBegin(), MSVehicleControl::loadedVehEnd(), POSITION_2_5D, POSITION_2D, POSITION_3D, POSITION_NONE, POSITION_ROADMAP, MSVehicle::processTraCICommands(), RandHelper::rand(), MSVehicle::reroute(), RTYPE_ERR, RTYPE_OK, tcpip::Storage::size(), tcpip::Storage::writeFloat(), tcpip::Storage::writeInt(), tcpip::Storage::writeString(), tcpip::Storage::writeUnsignedByte(), Position2D::x(), and Position2D::y().

                                                                                  {
    // Position representation
    int resType = myInputStorage.readUnsignedByte();
    if (resType != POSITION_NONE && resType != POSITION_2D && resType != POSITION_ROADMAP
            && resType != POSITION_2_5D && resType != POSITION_3D) {
        writeStatusCmd(CMD_SIMSTEP, RTYPE_ERR, "Error: unsupported return format requested.");
        return;
    }
    isMapChanged_ = true;
    // Everything is fine
    writeStatusCmd(CMD_SIMSTEP, RTYPE_OK, "");

    // prepare output
    try {
        MSNet *net = MSNet::getInstance();
        // map containing all active equipped vehicles. maps external id to MSVehicle*
        map<int, const MSVehicle*> activeEquippedVehicles;
        // get access to all vehicles in simulation
        MSVehicleControl &vehControl = net->getVehicleControl();
        // iterate over all vehicles in simulation
        for (map<string, MSVehicle*>::const_iterator iter = vehControl.loadedVehBegin();
                iter != vehControl.loadedVehEnd(); ++iter) {
            // selected vehicle
            const std::string vehicleId   = (*iter).first;
            const MSVehicle *vehicle = (*iter).second;
            // insert into equippedVehicleId if not contained
            std::map<std::string, int>::const_iterator equippedVeh = equippedVehicles_.find(vehicleId);
            if (equippedVeh == equippedVehicles_.end()) {
                // determine if vehicle is equipped
                if (penetration_ >= 1. || RandHelper::rand() <= penetration_) {
                    // vehicle is equipped
                    equippedVehicles_[vehicleId] = numEquippedVehicles_;
                    // put into active list?
                    if (vehicle->isOnRoad()) {
                        if ((myLifecycleSubscriptions.count(DOM_VEHICLE) != 0) &&
                                (myLivingVehicles.count(numEquippedVehicles_) == 0)) {
                            myCreatedVehicles.insert(numEquippedVehicles_);
                            myLivingVehicles.insert(numEquippedVehicles_);
                        }
                        activeEquippedVehicles[numEquippedVehicles_] = vehicle;
                    }
                    numEquippedVehicles_++;
                } else {
                    // vehicle is not equipped
                    equippedVehicles_[vehicleId] = -1;
                }
            } else if (equippedVeh->second >= 0 && vehicle->isOnRoad()) {
                int extId = equippedVeh->second;
                if ((myLifecycleSubscriptions.count(DOM_VEHICLE) != 0) &&
                        (myLivingVehicles.count(extId) == 0)) {
                    myCreatedVehicles.insert(extId);
                    myLivingVehicles.insert(extId);
                }
                activeEquippedVehicles[extId] = vehicle;
                // vehicle is equipped
            }
        }
        if (myLifecycleSubscriptions.count(DOM_VEHICLE) != 0) {
            // iterate over all vehicles that are supposed to live
            for (std::set<int>::iterator i = myLivingVehicles.begin();
                    i != myLivingVehicles.end();) {
                int extId = *i;
                if (activeEquippedVehicles.find(extId) == activeEquippedVehicles.end()) {
                    myDestroyedVehicles.insert(extId);
                    myLivingVehicles.erase(i++);
                } else {
                    i++;
                }
            }
        }

        handleLifecycleSubscriptions();

        // for each vehicle process any active traci command
        for (std::map<std::string, int>::iterator iter = equippedVehicles_.begin();
                iter != equippedVehicles_.end(); ++iter) {
            if ((*iter).second != -1) { // Look only at equipped vehicles
                MSVehicle* veh = net->getVehicleControl().getVehicle((*iter).first);
                if (myVehiclesToReroute.find(veh)!=myVehiclesToReroute.end()) {
                    // check rerouting
                    if (!veh->hasStops() && veh->isOnRoad() && veh->getLane().getEdge().getPurpose()!=MSEdge::EDGEFUNCTION_INTERNAL) {
                        MSNet::EdgeWeightsProxi proxi(veh->getWeightsStorage(), MSNet::getInstance()->getWeightsStorage());
                        DijkstraRouterTT_ByProxi<MSEdge, SUMOVehicle, prohibited_withRestrictions<MSEdge, SUMOVehicle>, MSNet::EdgeWeightsProxi> router(MSEdge::dictSize(), true, &proxi, &MSNet::EdgeWeightsProxi::getTravelTime);
                        veh->reroute(MSNet::getInstance()->getCurrentTimeStep(), router);
                    }
                    myVehiclesToReroute.erase(veh);
                }
                if (veh != NULL) {
                    veh->processTraCICommands(targetTime_);
                }
            }
        }

        handleDomainSubscriptions(targetTime_, activeEquippedVehicles);

        //out.writeChar( static_cast<unsigned char>(rtype) );
        //out.writeInt(numEquippedVehicles_);
        // iterate over all active equipped vehicles
        // and generate a Move Node command for each vehicle
        if (resType != POSITION_NONE) {
            for (map<int, const MSVehicle*>::iterator iter = activeEquippedVehicles.begin();
                    iter != activeEquippedVehicles.end(); ++iter) {
                int extId = (*iter).first;
                const MSVehicle* vehicle = (*iter).second;
                Storage tempMsg;

                // command type
                tempMsg.writeUnsignedByte(CMD_MOVENODE);
                // node id
                tempMsg.writeInt(extId);
                // end time
                tempMsg.writeInt(targetTime_);

                if (resType == POSITION_ROADMAP) {
                    // return type
                    tempMsg.writeUnsignedByte(POSITION_ROADMAP);

                    tempMsg.writeString(vehicle->getEdge()->getID());
                    tempMsg.writeFloat(vehicle->getPositionOnLane());

                    // determine index of the lane the vehicle is on
                    int laneId = 0;
                    const MSLane* lane = &vehicle->getLane();
                    while ((lane = lane->getRightLane()) != NULL) {
                        laneId++;
                    }
                    tempMsg.writeUnsignedByte(laneId);
                } else if (resType == POSITION_2D || resType == POSITION_3D || resType == POSITION_2_5D) {
                    tempMsg.writeUnsignedByte(resType);
                    Position2D pos = vehicle->getPosition();
                    tempMsg.writeFloat(pos.x());
                    tempMsg.writeFloat(pos.y());
                    if (resType != POSITION_2D) {
                        // z pos: ignored
                        tempMsg.writeFloat(0);
                    }
                }

                // command length
                myOutputStorage.writeUnsignedByte(tempMsg.size()+1);
                // content
                myOutputStorage.writeStorage(tempMsg);
            }
        }
    } catch (...) {
        writeStatusCmd(CMD_SIMSTEP, RTYPE_ERR, "some error happen in command: simulation step. Sumo shuts down.");
        closeConnection_ = true;
    }
}

void TraCIServer::postProcessSimulationStep2

(

)

throw (TraCIException, std::invalid_argument) [private]

Definition at line 684 of file TraCIServer.cpp.

References traci::TraCIServer::Subscription::beginTime, CMD_SIMSTEP2, traci::TraCIServer::Subscription::endTime, MSNet::getCurrentTimeStep(), MSNet::getInstance(), and RTYPE_OK.

                                                                                   {
    SUMOTime t = MSNet::getInstance()->getCurrentTimeStep();
    writeStatusCmd(CMD_SIMSTEP2, RTYPE_OK, "");
    int noActive = 0;
    for (std::vector<Subscription>::iterator i=mySubscriptions.begin(); i!=mySubscriptions.end();) {
        const Subscription &s = *i;
        if (s.endTime<t) {
            i = mySubscriptions.erase(i);
            continue;
        }
        ++i;
        if (s.beginTime>t) {
            continue;
        }
        ++noActive;
    }
    myOutputStorage.writeInt(noActive);
    for (std::vector<Subscription>::iterator i=mySubscriptions.begin(); i!=mySubscriptions.end(); ++i) {
        const Subscription &s = *i;
        if (s.beginTime>t) {
            continue;
        }
        tcpip::Storage into;
        std::string errors;
        processSingleSubscription(s, into, errors);
        myOutputStorage.writeStorage(into);
    }
}

void TraCIServer::processCommandsUntilSimStep

(

SUMOTime

step

)

throw (ProcessError) [static]

Definition at line 259 of file TraCIServer.cpp.

References CMD_SIMSTEP, CMD_SIMSTEP2, OptionsCont::getOptions(), tcpip::SocketException::what(), and traci::TraCIException::what().

Referenced by MSNet::simulationStep().

                                                                          {
    try {
        if (instance_ == 0) {
            if (!closeConnection_ && OptionsCont::getOptions().getInt("remote-port") != 0) {
                instance_ = new traci::TraCIServer();
            } else {
                return;
            }
        }
        if (step < instance_->targetTime_) {
            return;
        }
        // Simulation should run until
        // 1. end time reached or
        // 2. got CMD_CLOSE or
        // 3. Client closes socket connection
        if (instance_->myDoingSimStep) {
            switch (instance_->simStepCommand) {
            case CMD_SIMSTEP:
                instance_->postProcessSimulationStep();
                break;
            case CMD_SIMSTEP2:
                instance_->postProcessSimulationStep2();
                break;
            }
            instance_->myDoingSimStep = false;
        }
        while (!closeConnection_) {
            if (!instance_->myInputStorage.valid_pos()) {
                if (instance_->myOutputStorage.size() > 0) {
                    // send out all answers as one storage
                    instance_->socket_->sendExact(instance_->myOutputStorage);
                }
                instance_->myInputStorage.reset();
                instance_->myOutputStorage.reset();
                // Read a message
                instance_->socket_->receiveExact(instance_->myInputStorage);
            }
            while (instance_->myInputStorage.valid_pos() && !closeConnection_) {
                // dispatch each command
                int cmd = instance_->dispatchCommand();
                if (cmd == CMD_SIMSTEP || cmd==CMD_SIMSTEP2) {
                    instance_->simStepCommand = cmd;
                    instance_->myDoingSimStep = true;
                    for (std::map<MSNet::VehicleState, std::vector<std::string> >::iterator i=instance_->myVehicleStateChanges.begin(); i!=instance_->myVehicleStateChanges.end(); ++i) {
                        (*i).second.clear();
                    }
                    return;
                }
            }
        }
        if (closeConnection_ && instance_->myOutputStorage.size() > 0) {
            // send out all answers as one storage
            instance_->socket_->sendExact(instance_->myOutputStorage);
        }
        for (std::map<MSNet::VehicleState, std::vector<std::string> >::iterator i=instance_->myVehicleStateChanges.begin(); i!=instance_->myVehicleStateChanges.end(); ++i) {
            (*i).second.clear();
        }
    } catch (std::invalid_argument &e) {
        throw ProcessError(e.what());
    } catch (TraCIException &e) {
        throw ProcessError(e.what());
    } catch (SocketException &e) {
        throw ProcessError(e.what());
    }
    if (instance_ != NULL) {
        delete instance_;
        instance_ = 0;
        closeConnection_ = true;
    }
}

bool TraCIServer::processSingleSubscription	(	const TraCIServer::Subscription &	s,
		tcpip::Storage &	writeInto,
		std::string &	errors
	)			throw (TraCIException) [private]

Definition at line 3119 of file TraCIServer.cpp.

References CMD_SUBSCRIBE_EDGE_VARIABLE, CMD_SUBSCRIBE_INDUCTIONLOOP_VARIABLE, CMD_SUBSCRIBE_JUNCTION_VARIABLE, CMD_SUBSCRIBE_LANE_VARIABLE, CMD_SUBSCRIBE_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE, CMD_SUBSCRIBE_POI_VARIABLE, CMD_SUBSCRIBE_POLYGON_VARIABLE, CMD_SUBSCRIBE_ROUTE_VARIABLE, CMD_SUBSCRIBE_SIM_VARIABLE, CMD_SUBSCRIBE_TL_VARIABLE, CMD_SUBSCRIBE_VEHICLE_VARIABLE, CMD_SUBSCRIBE_VEHICLETYPE_VARIABLE, TraCIServerAPI_Simulation::processGet(), TraCIServerAPI_Edge::processGet(), TraCIServerAPI_Junction::processGet(), TraCIServerAPI_Polygon::processGet(), TraCIServerAPI_POI::processGet(), TraCIServerAPI_Route::processGet(), TraCIServerAPI_VehicleType::processGet(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Lane::processGet(), TraCIServerAPI_TLS::processGet(), TraCIServerAPI_MeMeDetector::processGet(), TraCIServerAPI_InductionLoop::processGet(), tcpip::Storage::readInt(), tcpip::Storage::readString(), tcpip::Storage::readUnsignedByte(), RTYPE_ERR, RTYPE_NOTIMPLEMENTED, RTYPE_OK, tcpip::Storage::size(), TYPE_STRING, TraCIServerAPIHelper::writeStatusCmd(), tcpip::Storage::writeString(), and tcpip::Storage::writeUnsignedByte().

                                                                                {
    bool ok = true;
    tcpip::Storage outputStorage;
    size_t wholeSize = 0;
    for (std::vector<int>::const_iterator i=s.variables.begin(); i!=s.variables.end(); ++i) {
        tcpip::Storage message;
        message.writeUnsignedByte(*i);
        message.writeString(s.id);
        tcpip::Storage tmpOutput;
        switch (s.commandId) {
            // generate response
        case CMD_SUBSCRIBE_INDUCTIONLOOP_VARIABLE:
            ok &= TraCIServerAPI_InductionLoop::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE:
            ok &= TraCIServerAPI_MeMeDetector::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_TL_VARIABLE:
            ok &= TraCIServerAPI_TLS::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_LANE_VARIABLE:
            ok &= TraCIServerAPI_Lane::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_VEHICLE_VARIABLE:
            ok &= TraCIServerAPI_Vehicle::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_VEHICLETYPE_VARIABLE:
            ok &= TraCIServerAPI_VehicleType::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_ROUTE_VARIABLE:
            ok &= TraCIServerAPI_Route::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_POI_VARIABLE:
            ok &= TraCIServerAPI_POI::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_POLYGON_VARIABLE:
            ok &= TraCIServerAPI_Polygon::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_JUNCTION_VARIABLE:
            ok &= TraCIServerAPI_Junction::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_EDGE_VARIABLE:
            ok &= TraCIServerAPI_Edge::processGet(message, tmpOutput, false);
            break;
        case CMD_SUBSCRIBE_SIM_VARIABLE:
            ok &= TraCIServerAPI_Simulation::processGet(message, tmpOutput, myVehicleStateChanges, false);
            break;
        default:
            TraCIServerAPIHelper::writeStatusCmd(s.commandId, RTYPE_NOTIMPLEMENTED, "Unsupported command specified", tmpOutput);
            ok = false;
            break;
        }
        // copy response part
        if (ok) {
            int length = tmpOutput.readUnsignedByte();
            length = tmpOutput.readInt();
            int responseType = tmpOutput.readUnsignedByte();
            int variable = tmpOutput.readUnsignedByte();
            std::string id = tmpOutput.readString();
            size_t p = 1 + 4 + 1 + 1 + 4 + id.length(); // cmd, var, id, type, value
            wholeSize += (length - p);
            outputStorage.writeUnsignedByte(variable);
            outputStorage.writeUnsignedByte(RTYPE_OK);
            while (p++<tmpOutput.size()) {
                outputStorage.writeUnsignedByte(tmpOutput.readUnsignedByte());
            }
        } else {
            int length = tmpOutput.readUnsignedByte();
            int cmd = tmpOutput.readUnsignedByte();
            int status = tmpOutput.readUnsignedByte();
            std::string msg = tmpOutput.readString();
            outputStorage.writeUnsignedByte(*i);
            outputStorage.writeUnsignedByte(RTYPE_ERR);
            outputStorage.writeUnsignedByte(TYPE_STRING);
            outputStorage.writeString(msg);
            errors = errors + msg;
        }
    }
    //writeStatusCmd(s.commandId, RTYPE_OK, "");
    writeInto.writeUnsignedByte(0); // command length -> extended
    writeInto.writeInt(1 + 4 + s.id.length() + 1 + outputStorage.size()); // extended length, length, cmd, id, varsize, return (x*1+size)
    writeInto.writeUnsignedByte(s.commandId + 0x10);
    writeInto.writeString(s.id);
    writeInto.writeUnsignedByte(s.variables.size());
    writeInto.writeStorage(outputStorage);
    return ok;
}

void TraCIServer::vehicleStateChanged	(	const MSVehicle *const	vehicle,
		MSNet::VehicleState	to
	)			throw () [virtual]

Called if a vehicle changes its state.

Parameters:

[in]	vehicle	The vehicle which changed its state
[in]	to	The state the vehicle has changed to

Implements MSNet::VehicleStateListener.

Definition at line 245 of file TraCIServer.cpp.

References OptionsCont::getOptions().

                                                                                              {
    if (closeConnection_ || OptionsCont::getOptions().getInt("remote-port") == 0) {
        return;
    }
    /*
    if(myVehicleStateChanges.find(to)==myVehicleStateChanges.end()) {
        myVehicleStateChanges[to] = std::vector<std::string>();
    }
    */
    myVehicleStateChanges[to].push_back(vehicle->getID());
}

bool TraCIServer::wasClosed

(

)

[static]

Definition at line 332 of file TraCIServer.cpp.

Referenced by GUIRunThread::makeStep(), MSNet::simulate(), and MSNet::simulationState().

                       {
    return closeConnection_;
}

void TraCIServer::writeStatusCmd	(	int	commandId,
		int	status,
		std::string	description
	)			[private]

Definition at line 1747 of file TraCIServer.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), RTYPE_ERR, RTYPE_NOTIMPLEMENTED, and toString().

                                                                            {
    if (status == RTYPE_ERR) {
        MsgHandler::getErrorInstance()->inform("Answered with error to command " + toString(commandId) +
                                               ": " + description);
    } else if (status == RTYPE_NOTIMPLEMENTED) {
        MsgHandler::getErrorInstance()->inform("Requested command not implemented (" + toString(commandId) +
                                               "): " + description);
    }

    // command length
    myOutputStorage.writeUnsignedByte(1 + 1 + 1 + 4 + static_cast<int>(description.length()));
    // command type
    myOutputStorage.writeUnsignedByte(commandId);
    // status
    myOutputStorage.writeUnsignedByte(status);
    // description
    myOutputStorage.writeString(description);

    return;
}

---

Field Documentation

bool TraCIServer::closeConnection_ = false [static, private]

Definition at line 310 of file TraCIServer.h.

std::map<std::string, int> traci::TraCIServer::equippedVehicles_ [private]

Definition at line 254 of file TraCIServer.h.

std::map<int, std::string> traci::TraCIServer::ext2intId [private]

Definition at line 258 of file TraCIServer.h.

TraCIServer * TraCIServer::instance_ = 0 [static, private]

Definition at line 238 of file TraCIServer.h.

bool traci::TraCIServer::isMapChanged_ [private]

Definition at line 259 of file TraCIServer.h.

std::set<int> traci::TraCIServer::myCreatedVehicles [private]

Definition at line 305 of file TraCIServer.h.

std::set<int> traci::TraCIServer::myDestroyedVehicles [private]

Definition at line 308 of file TraCIServer.h.

bool traci::TraCIServer::myDoingSimStep [private]

Definition at line 317 of file TraCIServer.h.

std::map<int, std::list<std::pair<int, int> > > traci::TraCIServer::myDomainSubscriptions [private]

Definition at line 299 of file TraCIServer.h.

tcpip::Storage traci::TraCIServer::myInputStorage [private]

Definition at line 315 of file TraCIServer.h.

std::set<int> traci::TraCIServer::myLifecycleSubscriptions [private]

Definition at line 296 of file TraCIServer.h.

std::set<int> traci::TraCIServer::myLivingVehicles [private]

Definition at line 302 of file TraCIServer.h.

tcpip::Storage traci::TraCIServer::myOutputStorage [private]

Definition at line 316 of file TraCIServer.h.

std::vector<Subscription> traci::TraCIServer::mySubscriptions [private]

Definition at line 335 of file TraCIServer.h.

std::map<MSNet::VehicleState, std::vector<std::string> > traci::TraCIServer::myVehicleStateChanges [private]

Definition at line 340 of file TraCIServer.h.

std::set<MSVehicle*> traci::TraCIServer::myVehiclesToReroute [private]

Definition at line 320 of file TraCIServer.h.

Boundary* traci::TraCIServer::netBoundary_ [private]

Definition at line 312 of file TraCIServer.h.

int traci::TraCIServer::numEquippedVehicles_ [private]

Definition at line 290 of file TraCIServer.h.

float traci::TraCIServer::penetration_ [private]

Definition at line 247 of file TraCIServer.h.

std::map<int, std::string> traci::TraCIServer::poiExt2IntId [private]

Definition at line 268 of file TraCIServer.h.

std::map<std::string, int> traci::TraCIServer::poiInt2ExtId [private]

Definition at line 270 of file TraCIServer.h.

std::map<int, std::string> traci::TraCIServer::polygonExt2IntId [private]

Definition at line 273 of file TraCIServer.h.

std::map<std::string, int> traci::TraCIServer::polygonInt2ExtId [private]

Definition at line 275 of file TraCIServer.h.

std::string traci::TraCIServer::routeFile_ [private]

Definition at line 250 of file TraCIServer.h.

int traci::TraCIServer::simStepCommand [private]

Definition at line 318 of file TraCIServer.h.

tcpip::Socket* traci::TraCIServer::socket_ [private]

Definition at line 241 of file TraCIServer.h.

SUMOTime traci::TraCIServer::targetTime_ [private]

Definition at line 244 of file TraCIServer.h.

int traci::TraCIServer::totalNumVehicles_ [private]

Definition at line 293 of file TraCIServer.h.

std::map<int, std::string> traci::TraCIServer::trafficLightsExt2IntId [private]

Definition at line 263 of file TraCIServer.h.

std::map<std::string, int> traci::TraCIServer::trafficLightsInt2ExtId [private]

Definition at line 265 of file TraCIServer.h.

---

The documentation for this class was generated from the following files:

• TraCIServer.h
• TraCIServer.cpp