void
TraCIServer::writeResponseWithLength(tcpip::Storage& outputStorage, tcpip::Storage& tempMsg) {
if (tempMsg.size() < 254) {
outputStorage.writeUnsignedByte(1 + (int)tempMsg.size()); // command length -> short
} else {
outputStorage.writeUnsignedByte(0); // command length -> extended
outputStorage.writeInt(1 + 4 + (int)tempMsg.size());
}
outputStorage.writeStorage(tempMsg);
}
bool
TraCIServer::processSingleSubscription(const Subscription& s, tcpip::Storage& writeInto,
std::string& errors) {
bool ok = true;
tcpip::Storage outputStorage;
const int getCommandId = s.contextVars ? s.contextDomain : s.commandId - 0x30;
std::set<std::string> objIDs;
if (s.contextVars) {
PositionVector shape;
if (!findObjectShape(s.commandId, s.id, shape)) {
return false;
}
collectObjectsInRange(s.contextDomain, shape, s.range, objIDs);
} else {
objIDs.insert(s.id);
}
const int numVars = s.contextVars && s.variables.size() == 1 && s.variables[0] == ID_LIST ? 0 : (int)s.variables.size();
for (std::set<std::string>::iterator j = objIDs.begin(); j != objIDs.end(); ++j) {
if (s.contextVars) {
outputStorage.writeString(*j);
}
if (numVars > 0) {
for (std::vector<int>::const_iterator i = s.variables.begin(); i != s.variables.end(); ++i) {
tcpip::Storage message;
message.writeUnsignedByte(*i);
message.writeString(*j);
tcpip::Storage tmpOutput;
if (myExecutors.find(getCommandId) != myExecutors.end()) {
ok &= myExecutors[getCommandId](*this, message, tmpOutput);
} else {
writeStatusCmd(s.commandId, RTYPE_NOTIMPLEMENTED, "Unsupported command specified", tmpOutput);
ok = false;
}
// copy response part
if (ok) {
int length = tmpOutput.readUnsignedByte();
while (--length > 0) {
tmpOutput.readUnsignedByte();
}
int lengthLength = 1;
length = tmpOutput.readUnsignedByte();
if (length == 0) {
lengthLength = 5;
length = tmpOutput.readInt();
}
//read responseType
tmpOutput.readUnsignedByte();
int variable = tmpOutput.readUnsignedByte();
std::string id = tmpOutput.readString();
outputStorage.writeUnsignedByte(variable);
outputStorage.writeUnsignedByte(RTYPE_OK);
length -= (lengthLength + 1 + 4 + (int)id.length());
while (--length > 0) {
outputStorage.writeUnsignedByte(tmpOutput.readUnsignedByte());
}
} else {
//read length
tmpOutput.readUnsignedByte();
//read cmd
tmpOutput.readUnsignedByte();
//read 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;
}
}
}
}
unsigned int length = (1 + 4) + 1 + (4 + (int)(s.id.length())) + 1 + (int)outputStorage.size();
if (s.contextVars) {
length += 4;
}
writeInto.writeUnsignedByte(0); // command length -> extended
writeInto.writeInt(length);
writeInto.writeUnsignedByte(s.commandId + 0x10);
writeInto.writeString(s.id);
if (s.contextVars) {
writeInto.writeUnsignedByte(s.contextDomain);
}
writeInto.writeUnsignedByte(numVars);
if (s.contextVars) {
writeInto.writeInt((int)objIDs.size());
}
if (!s.contextVars || objIDs.size() != 0) {
writeInto.writeStorage(outputStorage);
}
return ok;
}
// ===========================================================================
// method definitions
// ===========================================================================
bool
TraCIServerAPI_Lane::processGet(TraCIServer &server, tcpip::Storage &inputStorage,
tcpip::Storage &outputStorage) {
Storage tmpResult;
std::string warning = ""; // additional description for response
// variable
int variable = inputStorage.readUnsignedByte();
std::string id = inputStorage.readString();
// check variable
if (variable!=ID_LIST&&variable!=LANE_LINK_NUMBER&&variable!=LANE_EDGE_ID&&variable!=VAR_LENGTH
&&variable!=VAR_MAXSPEED&&variable!=LANE_LINKS&&variable!=VAR_SHAPE
&&variable!=VAR_CO2EMISSION&&variable!=VAR_COEMISSION&&variable!=VAR_HCEMISSION&&variable!=VAR_PMXEMISSION
&&variable!=VAR_NOXEMISSION&&variable!=VAR_FUELCONSUMPTION&&variable!=VAR_NOISEEMISSION
&&variable!=LAST_STEP_MEAN_SPEED&&variable!=LAST_STEP_VEHICLE_NUMBER
&&variable!=LAST_STEP_VEHICLE_ID_LIST&&variable!=LAST_STEP_OCCUPANCY&&variable!=LAST_STEP_VEHICLE_HALTING_NUMBER
&&variable!=LAST_STEP_LENGTH&&variable!=VAR_CURRENT_TRAVELTIME
&&variable!=LANE_ALLOWED&&variable!=LANE_DISALLOWED) {
server.writeStatusCmd(CMD_GET_LANE_VARIABLE, RTYPE_ERR, "Get Lane Variable: unsupported variable specified", outputStorage);
return false;
}
// begin response building
Storage tempMsg;
// response-code, variableID, objectID
tempMsg.writeUnsignedByte(RESPONSE_GET_LANE_VARIABLE);
tempMsg.writeUnsignedByte(variable);
tempMsg.writeString(id);
if (variable==ID_LIST) {
std::vector<std::string> ids;
MSLane::insertIDs(ids);
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(ids);
} else {
MSLane *lane = MSLane::dictionary(id);
if (lane==0) {
server.writeStatusCmd(CMD_GET_LANE_VARIABLE, RTYPE_ERR, "Lane '" + id + "' is not known", outputStorage);
return false;
}
switch (variable) {
case LANE_LINK_NUMBER:
tempMsg.writeUnsignedByte(TYPE_UBYTE);
tempMsg.writeUnsignedByte((int) lane->getLinkCont().size());
break;
case LANE_EDGE_ID:
tempMsg.writeUnsignedByte(TYPE_STRING);
tempMsg.writeString(lane->getEdge().getID());
break;
case VAR_LENGTH:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getLength());
break;
case VAR_MAXSPEED:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getMaxSpeed());
break;
case LANE_LINKS: {
tempMsg.writeUnsignedByte(TYPE_COMPOUND);
Storage tempContent;
unsigned int cnt = 0;
tempContent.writeUnsignedByte(TYPE_INTEGER);
const MSLinkCont &links = lane->getLinkCont();
tempContent.writeInt((int) links.size());
++cnt;
for (MSLinkCont::const_iterator i=links.begin(); i!=links.end(); ++i) {
MSLink *link = (*i);
// approached non-internal lane (if any)
tempContent.writeUnsignedByte(TYPE_STRING);
tempContent.writeString(link->getLane()!=0 ? link->getLane()->getID() : "");
++cnt;
// approached "via", internal lane (if any)
tempContent.writeUnsignedByte(TYPE_STRING);
#ifdef HAVE_INTERNAL_LANES
tempContent.writeString(link->getViaLane()!=0 ? link->getViaLane()->getID() : "");
#else
tempContent.writeString("");
#endif
++cnt;
// priority
tempContent.writeUnsignedByte(TYPE_UBYTE);
tempContent.writeUnsignedByte(link->havePriority() ? 1 : 0);
++cnt;
// opened
tempContent.writeUnsignedByte(TYPE_UBYTE);
tempContent.writeUnsignedByte(link->opened(MSNet::getInstance()->getCurrentTimeStep(), MSNet::getInstance()->getCurrentTimeStep(), 0.) ? 1 : 0);
++cnt;
// approaching foe
tempContent.writeUnsignedByte(TYPE_UBYTE);
tempContent.writeUnsignedByte(link->hasApproachingFoe(MSNet::getInstance()->getCurrentTimeStep(), MSNet::getInstance()->getCurrentTimeStep()) ? 1 : 0);
++cnt;
// state (not implemented, yet)
tempContent.writeUnsignedByte(TYPE_STRING);
tempContent.writeString("");
++cnt;
// direction (not implemented, yet)
tempContent.writeUnsignedByte(TYPE_STRING);
tempContent.writeString("");
++cnt;
// length
tempContent.writeUnsignedByte(TYPE_FLOAT);
tempContent.writeFloat(link->getLength());
++cnt;
}
tempMsg.writeInt((int) cnt);
tempMsg.writeStorage(tempContent);
}
break;
case LANE_ALLOWED: {
const std::vector<SUMOVehicleClass> &allowed = lane->getAllowedClasses();
std::vector<std::string> allowedS;
for (std::vector<SUMOVehicleClass>::const_iterator i=allowed.begin(); i!=allowed.end(); ++i) {
allowedS.push_back(getVehicleClassName(*i));
}
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(allowedS);
}
case LANE_DISALLOWED: {
const std::vector<SUMOVehicleClass> &disallowed = lane->getNotAllowedClasses();
std::vector<std::string> disallowedS;
for (std::vector<SUMOVehicleClass>::const_iterator i=disallowed.begin(); i!=disallowed.end(); ++i) {
disallowedS.push_back(getVehicleClassName(*i));
}
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(disallowedS);
}
break;
case VAR_SHAPE:
tempMsg.writeUnsignedByte(TYPE_POLYGON);
tempMsg.writeUnsignedByte(MIN2(static_cast<size_t>(255),lane->getShape().size()));
for (int iPoint=0; iPoint < MIN2(static_cast<size_t>(255),lane->getShape().size()); ++iPoint) {
tempMsg.writeFloat(lane->getShape()[iPoint].x());
tempMsg.writeFloat(lane->getShape()[iPoint].y());
}
break;
case VAR_CO2EMISSION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHBEFA_CO2Emissions());
break;
case VAR_COEMISSION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHBEFA_COEmissions());
break;
case VAR_HCEMISSION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHBEFA_HCEmissions());
break;
case VAR_PMXEMISSION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHBEFA_PMxEmissions());
break;
case VAR_NOXEMISSION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHBEFA_NOxEmissions());
break;
case VAR_FUELCONSUMPTION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHBEFA_FuelConsumption());
break;
case VAR_NOISEEMISSION:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getHarmonoise_NoiseEmissions());
break;
case LAST_STEP_VEHICLE_NUMBER:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt((int) lane->getVehicleNumber());
break;
case LAST_STEP_MEAN_SPEED:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getMeanSpeed());
break;
case LAST_STEP_VEHICLE_ID_LIST: {
std::vector<std::string> vehIDs;
const std::deque<MSVehicle*> &vehs = lane->getVehiclesSecure();
for (std::deque<MSVehicle*>::const_iterator j=vehs.begin(); j!=vehs.end(); ++j) {
vehIDs.push_back((*j)->getID());
}
lane->releaseVehicles();
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(vehIDs);
}
break;
case LAST_STEP_OCCUPANCY:
tempMsg.writeUnsignedByte(TYPE_FLOAT);
tempMsg.writeFloat(lane->getOccupancy());
break;
case LAST_STEP_VEHICLE_HALTING_NUMBER: {
int halting = 0;
const std::deque<MSVehicle*> &vehs = lane->getVehiclesSecure();
for (std::deque<MSVehicle*>::const_iterator j=vehs.begin(); j!=vehs.end(); ++j) {
if ((*j)->getSpeed()<0.1) {
++halting;
}
}
lane->releaseVehicles();
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt(halting);
}
break;
case LAST_STEP_LENGTH: {
SUMOReal lengthSum = 0;
const std::deque<MSVehicle*> &vehs = lane->getVehiclesSecure();
for (std::deque<MSVehicle*>::const_iterator j=vehs.begin(); j!=vehs.end(); ++j) {
lengthSum += (*j)->getVehicleType().getLength();
}
tempMsg.writeUnsignedByte(TYPE_FLOAT);
if (vehs.size()==0) {
tempMsg.writeFloat(0);
} else {
tempMsg.writeFloat(lengthSum / (SUMOReal) vehs.size());
}
lane->releaseVehicles();
}
break;
case VAR_CURRENT_TRAVELTIME: {
SUMOReal meanSpeed = lane->getMeanSpeed();
tempMsg.writeUnsignedByte(TYPE_FLOAT);
if (meanSpeed!=0) {
tempMsg.writeFloat(lane->getLength() / meanSpeed);
} else {
tempMsg.writeFloat(1000000.);
}
}
break;
default:
break;
}
}
server.writeStatusCmd(CMD_GET_LANE_VARIABLE, RTYPE_OK, warning, outputStorage);
// send response
outputStorage.writeUnsignedByte(0); // command length -> extended
outputStorage.writeInt(1 + 4 + tempMsg.size());
outputStorage.writeStorage(tempMsg);
return true;
}
