bool
GNEDetectorE2::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidDetectorID(value);
case SUMO_ATTR_LANE:
if (value.empty()) {
return false;
} else {
return canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false);
}
case SUMO_ATTR_LANES:
if (value.empty()) {
return false;
} else if (canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false)) {
// check if lanes are consecutives
return lanesConsecutives(parse<std::vector<GNELane*> >(myViewNet->getNet(), value));
} else {
return false;
}
case SUMO_ATTR_POSITION:
return canParse<double>(value);
case SUMO_ATTR_ENDPOS:
return canParse<double>(value);
case SUMO_ATTR_FREQUENCY:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_LENGTH:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_NAME:
return SUMOXMLDefinitions::isValidAttribute(value);
case SUMO_ATTR_FILE:
return SUMOXMLDefinitions::isValidFilename(value);
case SUMO_ATTR_VTYPES:
if (value.empty()) {
return true;
} else {
return SUMOXMLDefinitions::isValidListOfTypeID(value);
}
case SUMO_ATTR_HALTING_TIME_THRESHOLD:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_HALTING_SPEED_THRESHOLD:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_JAM_DIST_THRESHOLD:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEPOI::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return SUMOXMLDefinitions::isValidNetID(value) && (myNet->retrievePOI(value, false) == nullptr);
case SUMO_ATTR_COLOR:
return canParse<RGBColor>(value);
case SUMO_ATTR_LANE:
return (myNet->retrieveLane(value, false) != nullptr);
case SUMO_ATTR_POSITION:
if (getLaneParents().size() > 0) {
return canParse<double>(value);
} else {
return canParse<Position>(value);
}
case SUMO_ATTR_POSITION_LAT:
return canParse<double>(value);
case SUMO_ATTR_GEOPOSITION: {
return canParse<Position>(value);
}
case SUMO_ATTR_GEO:
return canParse<bool>(value);
case SUMO_ATTR_TYPE:
return true;
case SUMO_ATTR_LAYER:
if (value == "default") {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_IMGFILE:
if (value == "") {
return true;
} else {
// check that image can be loaded
return GUITexturesHelper::getTextureID(value) != -1;
}
case SUMO_ATTR_RELATIVEPATH:
return canParse<bool>(value);
case SUMO_ATTR_WIDTH:
return canParse<double>(value) && (parse<double>(value) >= 0);
case SUMO_ATTR_HEIGHT:
return canParse<double>(value) && (parse<double>(value) >= 0);
case SUMO_ATTR_ANGLE:
return canParse<double>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNECrossing::isValid(SumoXMLAttr key, const std::string& value) {
auto crossing = myParentJunction->getNBNode()->getCrossing(myCrossingEdges);
switch (key) {
case SUMO_ATTR_ID:
return false;
case SUMO_ATTR_EDGES:
if (canParse<std::vector<GNEEdge*> >(myNet, value, false)) {
// parse edges and save their IDs in a set
std::vector<GNEEdge*> parsedEdges = parse<std::vector<GNEEdge*> >(myNet, value);
EdgeVector nbEdges;
for (auto i : parsedEdges) {
nbEdges.push_back(i->getNBEdge());
}
std::sort(nbEdges.begin(), nbEdges.end());
//
EdgeVector originalEdges = crossing->edges;
std::sort(originalEdges.begin(), originalEdges.end());
// return true if we're setting the same edges
if (toString(nbEdges) == toString(originalEdges)) {
return true;
} else {
return !myParentJunction->getNBNode()->checkCrossingDuplicated(nbEdges);
}
} else {
return false;
}
case SUMO_ATTR_WIDTH:
return canParse<double>(value) && ((parse<double>(value) > 0) || (parse<double>(value) == -1)); // kann NICHT 0 sein, oder -1 (bedeutet default)
case SUMO_ATTR_PRIORITY:
return canParse<bool>(value);
case SUMO_ATTR_TLLINKINDEX:
case SUMO_ATTR_TLLINKINDEX2:
return (crossing->tlID != "" && canParse<int>(value)
// -1 means that tlLinkIndex2 takes on the same value as tlLinkIndex when setting idnices
&& ((parse<double>(value) >= 0) || ((parse<double>(value) == -1) && (key == SUMO_ATTR_TLLINKINDEX2)))
&& myParentJunction->getNBNode()->getControllingTLS().size() > 0
&& (*myParentJunction->getNBNode()->getControllingTLS().begin())->getMaxValidIndex() >= parse<int>(value));
case SUMO_ATTR_CUSTOMSHAPE: {
// empty shapes are allowed
return canParse<PositionVector>(value);
}
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNERouteProbReroute::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_ROUTE:
return SUMOXMLDefinitions::isValidVehicleID(value);
case SUMO_ATTR_PROB:
return canParse<double>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEClosingLaneReroute::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_LANE:
return (myViewNet->getNet()->retrieveLane(value, false) != nullptr);
case SUMO_ATTR_ALLOW:
case SUMO_ATTR_DISALLOW:
return canParseVehicleClasses(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEConnection::isValid(SumoXMLAttr key, const std::string& value) {
// Currently ignored before implementation to avoid warnings
switch (key) {
case SUMO_ATTR_FROM:
case SUMO_ATTR_TO:
case SUMO_ATTR_FROM_LANE:
case SUMO_ATTR_TO_LANE:
return false;
case SUMO_ATTR_PASS:
return canParse<bool>(value);
case SUMO_ATTR_KEEP_CLEAR:
return canParse<bool>(value);
case SUMO_ATTR_CONTPOS:
return canParse<double>(value);
case SUMO_ATTR_UNCONTROLLED:
return canParse<bool>(value);
case SUMO_ATTR_VISIBILITY_DISTANCE:
return canParse<double>(value) && (parse<double>(value) > 0);
case SUMO_ATTR_TLLINKINDEX:
if (getNBEdgeConnection().uncontrolled == false
&& getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().size() > 0
&& canParse<int>(value)
&& parse<int>(value) >= 0) {
NBTrafficLightDefinition* def = *getEdgeFrom()->getNBEdge()->getToNode()->getControllingTLS().begin();
return def->getMaxValidIndex() >= parse<int>(value);
} else {
return false;
}
case SUMO_ATTR_SPEED:
return canParse<double>(value) && (parse<double>(value) > 0);
case SUMO_ATTR_CUSTOMSHAPE: {
// empty custom shapes are allowed
return canParse<PositionVector>(value);
}
case SUMO_ATTR_STATE:
return false;
case SUMO_ATTR_DIR:
return false;
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNECalibrator::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_EDGE:
if (myViewNet->getNet()->retrieveEdge(value, false) != nullptr) {
return true;
} else {
return false;
}
case SUMO_ATTR_LANE:
if (myViewNet->getNet()->retrieveLane(value, false) != nullptr) {
return true;
} else {
return false;
}
case SUMO_ATTR_POSITION:
if (canParse<double>(value)) {
// obtain position and check if is valid
double newPosition = parse<double>(value);
PositionVector shape = (getLaneParents().size() > 0) ? getLaneParents().front()->getGeometry().shape : getEdgeParents().front()->getLanes().at(0)->getGeometry().shape;
if ((newPosition < 0) || (newPosition > shape.length())) {
return false;
} else {
return true;
}
} else {
return false;
}
case SUMO_ATTR_FREQUENCY:
return (canParse<double>(value) && parse<double>(value) >= 0);
case SUMO_ATTR_NAME:
return SUMOXMLDefinitions::isValidAttribute(value);
case SUMO_ATTR_OUTPUT:
return SUMOXMLDefinitions::isValidFilename(value);
case SUMO_ATTR_ROUTEPROBE:
return SUMOXMLDefinitions::isValidNetID(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEAccess::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_LANE: {
GNELane* lane = myViewNet->getNet()->retrieveLane(value, false);
if (lane != nullptr) {
if (getLaneParents().front()->getParentEdge().getID() != lane->getParentEdge().getID()) {
return GNEAdditionalHandler::accessCanBeCreated(getAdditionalParents().at(0), lane->getParentEdge());
} else {
return true;
}
} else {
return false;
}
}
case SUMO_ATTR_POSITION:
if (value.empty()) {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_LENGTH:
if (value.empty()) {
return true;
} else {
return (canParse<double>(value) && (parse<double>(value) >= 0));
}
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEDetectorExit::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_LANE:
return (myViewNet->getNet()->retrieveLane(value, false) != nullptr);
case SUMO_ATTR_POSITION:
return canParse<double>(value);
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_PARENT:
return (myViewNet->getNet()->retrieveAdditional(SUMO_TAG_E3DETECTOR, value, false) != nullptr);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEDetectorE1::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidDetectorID(value);
case SUMO_ATTR_LANE:
if (myViewNet->getNet()->retrieveLane(value, false) != nullptr) {
return true;
} else {
return false;
}
case SUMO_ATTR_POSITION:
return canParse<double>(value) && fabs(parse<double>(value)) < getLaneParents().front()->getParentEdge().getNBEdge()->getFinalLength();
case SUMO_ATTR_FREQUENCY:
return (canParse<double>(value) && (parse<double>(value) >= 0));
case SUMO_ATTR_NAME:
return SUMOXMLDefinitions::isValidAttribute(value);
case SUMO_ATTR_FILE:
return SUMOXMLDefinitions::isValidFilename(value);
case SUMO_ATTR_VTYPES:
if (value.empty()) {
return true;
} else {
return SUMOXMLDefinitions::isValidListOfTypeID(value);
}
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
case GNE_ATTR_BLOCK_MOVEMENT:
return canParse<bool>(value);
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNECalibratorFlow::isValid(SumoXMLAttr key, const std::string& value) {
switch (key) {
case SUMO_ATTR_ID:
return isValidAdditionalID(value);
case SUMO_ATTR_TYPE:
return SUMOXMLDefinitions::isValidTypeID(value) && (myViewNet->getNet()->retrieveDemandElement(SUMO_TAG_VTYPE, value, false) != nullptr);
case SUMO_ATTR_ROUTE:
return SUMOXMLDefinitions::isValidVehicleID(value) && (myViewNet->getNet()->retrieveAdditional(SUMO_TAG_ROUTE, value, false) != nullptr);
case SUMO_ATTR_VEHSPERHOUR:
if (value.empty()) {
// speed and vehsPerHour cannot be empty at the same time
if (mySpeed.empty()) {
return false;
} else {
return true;
}
} else if (canParse<double>(value)) {
return (parse<double>(value) >= 0);
} else {
return false;
}
case SUMO_ATTR_SPEED:
if (value.empty()) {
// speed and vehsPerHour cannot be empty at the same time
if (myVehsPerHour.empty()) {
return false;
} else {
return true;
}
} else if (canParse<double>(value)) {
return (parse<double>(value) >= 0);
} else {
return false;
}
case SUMO_ATTR_COLOR:
return canParse<RGBColor>(value);
case SUMO_ATTR_BEGIN:
return canParse<double>(value) && (parse<double>(value) >= 0);
case SUMO_ATTR_END:
return canParse<double>(value) && (parse<double>(value) >= 0);
case SUMO_ATTR_DEPARTLANE:
if ((value == "random") || (value == "free") || (value == "allowed") || (value == "best") || (value == "first")) {
return true;
} else {
return (myViewNet->getNet()->retrieveLane(value, false) != nullptr);
}
case SUMO_ATTR_DEPARTPOS:
if ((value == "random") || (value == "free") || (value == "random_free") || (value == "base") || (value == "last")) {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_DEPARTSPEED:
if ((value == "random") || (value == "max")) {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_ARRIVALLANE:
if (value == "current") {
return true;
} else {
return (myViewNet->getNet()->retrieveLane(value, false) != nullptr);
}
case SUMO_ATTR_ARRIVALPOS:
if ((value == "random") || (value == "max")) {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_ARRIVALSPEED:
if (value == "current") {
return true;
} else {
return canParse<double>(value);
}
case SUMO_ATTR_LINE:
return true;
case SUMO_ATTR_PERSON_NUMBER:
return canParse<int>(value) && parse<int>(value) >= 0;
case SUMO_ATTR_CONTAINER_NUMBER:
return canParse<int>(value) && parse<int>(value) >= 0;
case SUMO_ATTR_REROUTE:
return canParse<bool>(value);
case SUMO_ATTR_DEPARTPOS_LAT:
return SUMOXMLDefinitions::LateralAlignments.hasString(value);
case SUMO_ATTR_ARRIVALPOS_LAT:
return SUMOXMLDefinitions::LateralAlignments.hasString(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
bool
GNEStop::isValid(SumoXMLAttr key, const std::string& value) {
// declare string error
std::string error;
switch (key) {
case SUMO_ATTR_ID:
return isValidDemandElementID(value);
case SUMO_ATTR_DURATION:
case SUMO_ATTR_UNTIL:
if (canParse<SUMOTime>(value)) {
return parse<SUMOTime>(value) >= 0;
} else {
return false;
}
case SUMO_ATTR_INDEX:
if ((value == "fit") || (value == "end")) {
return true;
} else if (canParse<int>(value)) {
return (parse<int>(value) >= 0);
} else {
return false;
}
case SUMO_ATTR_TRIGGERED:
return canParse<bool>(value);
case SUMO_ATTR_CONTAINER_TRIGGERED:
return canParse<bool>(value);
case SUMO_ATTR_EXPECTED:
case SUMO_ATTR_EXPECTED_CONTAINERS:
if (value.empty()) {
return true;
} else {
return canParse<std::vector<std::string> >(value);
}
case SUMO_ATTR_PARKING:
return canParse<bool>(value);
case SUMO_ATTR_ACTTYPE:
return false; // CHECK
case SUMO_ATTR_TRIP_ID:
return SUMOXMLDefinitions::isValidAttribute(value);
// specific of Stops over stoppingPlaces
case SUMO_ATTR_BUS_STOP:
return (myViewNet->getNet()->retrieveAdditional(SUMO_TAG_BUS_STOP, value, false) != nullptr);
case SUMO_ATTR_CONTAINER_STOP:
return (myViewNet->getNet()->retrieveAdditional(SUMO_TAG_CONTAINER_STOP, value, false) != nullptr);
case SUMO_ATTR_CHARGING_STATION:
return (myViewNet->getNet()->retrieveAdditional(SUMO_TAG_CHARGING_STATION, value, false) != nullptr);
case SUMO_ATTR_PARKING_AREA:
return (myViewNet->getNet()->retrieveAdditional(SUMO_TAG_PARKING_AREA, value, false) != nullptr);
// specific of stops over lanes
case SUMO_ATTR_LANE:
if (myViewNet->getNet()->retrieveLane(value, false) != nullptr) {
return true;
} else {
return false;
}
case SUMO_ATTR_STARTPOS:
if (value.empty()) {
return true;
} else if (canParse<double>(value)) {
return GNEStoppingPlace::checkStoppinPlacePosition(value, toString(endPos), getLaneParents().front()->getParentEdge().getNBEdge()->getFinalLength(), myFriendlyPosition);
} else {
return false;
}
case SUMO_ATTR_ENDPOS:
if (value.empty()) {
return true;
} else if (canParse<double>(value)) {
return GNEStoppingPlace::checkStoppinPlacePosition(toString(startPos), value, getLaneParents().front()->getParentEdge().getNBEdge()->getFinalLength(), myFriendlyPosition);
} else {
return false;
}
case SUMO_ATTR_FRIENDLY_POS:
return canParse<bool>(value);
//
case GNE_ATTR_SELECTED:
return canParse<bool>(value);
case GNE_ATTR_GENERIC:
return isGenericParametersValid(value);
default:
throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'");
}
}
