org.opentrafficsim.trafficcontrol.trafcod.TrafCod Maven / Gradle / Ivy
The newest version!
package org.opentrafficsim.trafficcontrol.trafcod;
import java.awt.Container;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import javax.swing.JPanel;
import org.djunits.unit.DurationUnit;
import org.djunits.value.vdouble.scalar.Duration;
import org.djutils.event.Event;
import org.djutils.event.EventListener;
import org.djutils.event.EventType;
import org.djutils.exceptions.Throw;
import org.djutils.immutablecollections.ImmutableCollection;
import org.opentrafficsim.core.dsol.OtsModelInterface;
import org.opentrafficsim.core.dsol.OtsSimulatorInterface;
import org.opentrafficsim.core.network.Network;
import org.opentrafficsim.core.network.NetworkException;
import org.opentrafficsim.core.object.LocatedObject;
import org.opentrafficsim.road.network.lane.object.detector.TrafficLightDetector;
import org.opentrafficsim.road.network.lane.object.detector.TrafficLightDetector.StartEndDetector;
import org.opentrafficsim.road.network.lane.object.trafficlight.TrafficLight;
import org.opentrafficsim.road.network.lane.object.trafficlight.TrafficLightColor;
import org.opentrafficsim.trafficcontrol.AbstractTrafficController;
import org.opentrafficsim.trafficcontrol.ActuatedTrafficController;
import org.opentrafficsim.trafficcontrol.TrafficControlException;
import org.opentrafficsim.trafficcontrol.TrafficController;
import nl.tudelft.simulation.dsol.SimRuntimeException;
/**
* TrafCOD evaluator. TrafCOD is a language for writing traffic control programs. A TrafCOD program consists of a set of rules
* that must be evaluated repeatedly (until no more changes occurr) every time step. The time step size is 0.1 seconds.
*
* Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
* BSD-style license. See OpenTrafficSim License.
*
* @author Wouter Schakel
*/
public class TrafCod extends AbstractTrafficController implements ActuatedTrafficController, EventListener
{
/** */
private static final long serialVersionUID = 20161014L;
/** Version of the supported TrafCOD files. */
static final int TrafCod_VERSION = 100;
/** The evaluation interval of TrafCOD. */
static final Duration EVALUATION_INTERVAL = new Duration(0.1, DurationUnit.SECOND);
/** Text leading up to the TrafCOD version number. */
private static final String VERSION_PREFIX = "trafcod-version=";
/** Text on line before the sequence line. */
private static final String SEQUENCE_KEY = "Sequence";
/** Text leading up to the control program structure. */
private static final String STRUCTURE_PREFIX = "Structure:";
/** The tokenized rules. */
private final List tokenisedRules = new ArrayList<>();
/** The TrafCOD variables. */
private final Map variables = new LinkedHashMap<>();
/** The TrafCOD variables in order of definition. */
private final List variablesInDefinitionOrder = new ArrayList<>();
/** The detectors. */
private final Map detectors = new LinkedHashMap<>();
/** Comment starter in TrafCOD. */
static final String COMMENT_PREFIX = "#";
/** Prefix for initialization rules. */
private static final String INIT_PREFIX = "%init ";
/** Prefix for time initializer rules. */
private static final String TIME_PREFIX = "%time ";
/** Prefix for export rules. */
private static final String EXPORT_PREFIX = "%export ";
/** Number of conflict groups in the control program. */
private int numberOfConflictGroups = -1;
/** Sequence information; size of conflict group. */
private int conflictGroupSize = -1;
/** Chosen structure number (as assigned by VRIGen). */
private int structureNumber = -1;
/** The conflict groups in order that they will be served. */
private List> conflictGroups = new ArrayList>();
/** Maximum number of evaluation loops. */
private int maxLoopCount = 10;
/** Position in current expression. */
private int currentToken;
/** The expression evaluation stack. */
private List stack = new ArrayList();
/** Rule that is currently being evaluated. */
private Object[] currentRule;
/** The current time in units of 0.1 s. */
private int currentTime10 = 0;
/** The unparsed TrafCOD rules (needed for cloning). */
private final List trafCODRules;
/** Container for controller state display. */
private final Container displayContainer = new JPanel();
/** Background image for state display. */
private final BufferedImage displayBackground;
/** Objects to draw on top of display background. */
private final List displayObjectLocations;
/** Animation of the current state of this TrafCOD controller. */
private TrafCodDisplay stateDisplay = null;
/** The simulation engine. */
private final OtsSimulatorInterface simulator;
/** Space-separated list of the traffic streams in the currently active conflict group. */
private String currentConflictGroup = "";
/**
* Construct a new TrafCOD traffic light controller.
* @param controllerName String; name of this TrafCOD traffic light controller
* @param trafCodURL URL; the URL of the TrafCOD rules
* @param simulator OtsSimulatorInterface; the simulation engine
* @param display Container; if non-null, a controller display is constructed and shown in the supplied container
* @param displayBackground BufferedImage; background for controller display image
* @param displayObjectLocations List<String>; list of sensors and traffic lights and their locations on the
* displayBackGround
* @throws TrafficControlException when a rule cannot be parsed
* @throws SimRuntimeException when scheduling the first evaluation event fails
* @throws IOException when loading the TrafCOD rules from the URL fails
*/
public TrafCod(final String controllerName, final URL trafCodURL, final OtsSimulatorInterface simulator,
final Container display, final BufferedImage displayBackground, final List displayObjectLocations)
throws TrafficControlException, SimRuntimeException, IOException
{
this(controllerName, loadTextFromURL(trafCodURL), simulator, displayBackground, displayObjectLocations);
}
/**
* Construct a new TrafCOD traffic light controller.
* @param controllerName String; name of this TrafCOD traffic light controller
* @param trafCODRules List<String>; the TrafCOD rules
* @param simulator OtsSimulatorInterface; the simulation engine
* @param displayBackground BufferedImage; background for controller display image
* @param displayObjectLocations List<String>; list of sensors and traffic lights and their locations on the
* displayBackGround
* @throws TrafficControlException when a rule cannot be parsed
* @throws SimRuntimeException when scheduling the first evaluation event fails
*/
public TrafCod(final String controllerName, final List trafCODRules, final OtsSimulatorInterface simulator,
final BufferedImage displayBackground, final List displayObjectLocations)
throws TrafficControlException, SimRuntimeException
{
super(controllerName, simulator);
Throw.whenNull(controllerName, "controllerName may not be null");
Throw.whenNull(simulator, "simulator may not be null");
this.simulator = simulator;
this.displayBackground = displayBackground;
this.displayObjectLocations = displayObjectLocations;
Throw.whenNull(trafCODRules, "trafCodRules may not be null");
this.trafCODRules = trafCODRules;
parseTrafCODRules();
// Initialize the variables that have a non-zero initial value
for (Variable v : this.variablesInDefinitionOrder)
{
v.initialize();
double value = v.getValue();
if (v.isTimer())
{
value /= 10.0;
}
fireTimedEvent(TrafficController.TRAFFICCONTROL_VARIABLE_CREATED,
new Object[] {getId(), v.getName(), v.getStream(), value}, simulator.getSimulatorTime());
}
if (null != this.displayContainer && null != this.displayBackground && null != this.displayObjectLocations)
{
this.stateDisplay = new TrafCodDisplay(this.displayBackground);
this.displayContainer.add(this.stateDisplay);
try
{
addTrafCODDisplay(this.displayObjectLocations);
}
catch (IOException e)
{
e.printStackTrace();
}
}
// Schedule the consistency check (don't call it directly) to allow interested parties to subscribe before the
// consistency check is performed
this.simulator.scheduleEventRel(Duration.ZERO, this, "checkConsistency", null);
// The first rule evaluation should occur at t=0.1s
this.simulator.scheduleEventRel(EVALUATION_INTERVAL, this, "evalExprs", null);
}
/**
* Read a text from a URL and convert it to a list of strings.
* @param url URL; the URL to open and read
* @return List<String>; the lines read from the URL (trimmed).
* @throws IOException when opening or reading the URL failed.
*/
public static List loadTextFromURL(final URL url) throws IOException
{
List result = new ArrayList<>();
BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
String inputLine;
while ((inputLine = in.readLine()) != null)
{
result.add(inputLine.trim());
}
return result;
}
/**
* Read and parse the TrafCOD traffic control program.
* @throws TrafficControlException when the TrafCOD file contains errors
*/
private void parseTrafCODRules() throws TrafficControlException
{
for (int lineno = 0; lineno < this.trafCODRules.size(); lineno++)
{
String trimmedLine = this.trafCODRules.get(lineno);
// System.out.println(lineno + ":\t" + inputLine);
if (trimmedLine.length() == 0)
{
continue;
}
String locationDescription = "TrafCOD rule" + "(" + lineno + ") ";
if (trimmedLine.startsWith(COMMENT_PREFIX))
{
String commentStripped = trimmedLine.substring(1).trim();
if (stringBeginsWithIgnoreCase(VERSION_PREFIX, commentStripped))
{
String versionString = commentStripped.substring(VERSION_PREFIX.length());
try
{
int observedVersion = Integer.parseInt(versionString);
if (TrafCod_VERSION != observedVersion)
{
throw new TrafficControlException(
"Wrong TrafCOD version (expected " + TrafCod_VERSION + ", got " + observedVersion + ")");
}
}
catch (NumberFormatException nfe)
{
nfe.printStackTrace();
throw new TrafficControlException("Could not parse TrafCOD version (got \"" + versionString + ")");
}
}
else if (stringBeginsWithIgnoreCase(SEQUENCE_KEY, commentStripped))
{
while (trimmedLine.startsWith(COMMENT_PREFIX))
{
if (++lineno >= this.trafCODRules.size())
{
throw new TrafficControlException(
"Unexpected EOF (reading sequence key at " + locationDescription + ")");
}
trimmedLine = this.trafCODRules.get(lineno);
}
String[] fields = trimmedLine.split("\\s");
Throw.when(fields.length != 2, TrafficControlException.class,
"Wrong number of fields in Sequence information line (%s)", trimmedLine);
try
{
this.numberOfConflictGroups = Integer.parseInt(fields[0]);
this.conflictGroupSize = Integer.parseInt(fields[1]);
}
catch (NumberFormatException nfe)
{
nfe.printStackTrace();
throw new TrafficControlException("Bad number of conflict groups or bad conflict group size");
}
}
else if (stringBeginsWithIgnoreCase(STRUCTURE_PREFIX, commentStripped))
{
String structureNumberString = commentStripped.substring(STRUCTURE_PREFIX.length()).trim();
try
{
this.structureNumber = Integer.parseInt(structureNumberString);
}
catch (NumberFormatException nfe)
{
nfe.printStackTrace();
throw new TrafficControlException(
"Bad structure number (got \"" + structureNumberString + "\" at " + locationDescription + ")");
}
for (int i = 0; i < this.conflictGroupSize; i++)
{
this.conflictGroups.add(new ArrayList());
}
for (int conflictMemberLine = 0; conflictMemberLine < this.numberOfConflictGroups; conflictMemberLine++)
{
if (++lineno >= this.trafCODRules.size())
{
throw new TrafficControlException(
"Unexpected EOF (reading conflict groups at " + locationDescription + ")");
}
trimmedLine = this.trafCODRules.get(lineno);
while (trimmedLine.startsWith(COMMENT_PREFIX))
{
if (++lineno >= this.trafCODRules.size())
{
throw new TrafficControlException(
"Unexpected EOF (reading conflict groups at " + locationDescription + ")");
}
trimmedLine = this.trafCODRules.get(lineno);
}
String[] fields = trimmedLine.split("\\s+");
if (fields.length != this.conflictGroupSize)
{
throw new TrafficControlException("Wrong number of conflict groups in Structure information");
}
for (int col = 0; col < this.conflictGroupSize; col++)
{
try
{
Short stream = Short.parseShort(fields[col]);
this.conflictGroups.get(col).add(stream);
}
catch (NumberFormatException nfe)
{
nfe.printStackTrace();
throw new TrafficControlException("Wrong number of streams in conflict group " + trimmedLine);
}
}
}
}
continue;
}
if (stringBeginsWithIgnoreCase(INIT_PREFIX, trimmedLine))
{
String varNameAndInitialValue = trimmedLine.substring(INIT_PREFIX.length()).trim().replaceAll("[ \t]+", " ");
String[] fields = varNameAndInitialValue.split(" ");
NameAndStream nameAndStream = new NameAndStream(fields[0], locationDescription);
installVariable(nameAndStream.getName(), nameAndStream.getStream(), EnumSet.noneOf(Flags.class),
locationDescription).setFlag(Flags.INITED);
// The supplied initial value is ignored (in this version of the TrafCOD interpreter)!
continue;
}
if (stringBeginsWithIgnoreCase(TIME_PREFIX, trimmedLine))
{
String timerNameAndMaximumValue = trimmedLine.substring(INIT_PREFIX.length()).trim().replaceAll("[ \t]+", " ");
String[] fields = timerNameAndMaximumValue.split(" ");
NameAndStream nameAndStream = new NameAndStream(fields[0], locationDescription);
Variable variable = installVariable(nameAndStream.getName(), nameAndStream.getStream(),
EnumSet.noneOf(Flags.class), locationDescription);
int value10 = Integer.parseInt(fields[1]);
variable.setTimerMax(value10);
continue;
}
if (stringBeginsWithIgnoreCase(EXPORT_PREFIX, trimmedLine))
{
String varNameAndOutputValue = trimmedLine.substring(EXPORT_PREFIX.length()).trim().replaceAll("[ \t]+", " ");
String[] fields = varNameAndOutputValue.split(" ");
NameAndStream nameAndStream = new NameAndStream(fields[0], locationDescription);
Variable variable = installVariable(nameAndStream.getName(), nameAndStream.getStream(),
EnumSet.noneOf(Flags.class), locationDescription);
int value = Integer.parseInt(fields[1]);
variable.setOutput(value);
continue;
}
Object[] tokenisedRule = parse(trimmedLine, locationDescription);
if (null != tokenisedRule && tokenisedRule.length > 0)
{
this.tokenisedRules.add(tokenisedRule);
}
}
}
/**
* Check the consistency of the traffic control program and perform initializations that require a completely built network.
* @throws SimRuntimeException when the simulation model is not an OtsModelInterface
* @throws TrafficControlException when a required traffic light or sensor is not present in the network
*/
public void checkConsistency() throws SimRuntimeException, TrafficControlException
{
for (Variable v : this.variablesInDefinitionOrder)
{
if (0 == v.getRefCount() && (!v.isOutput()) && (!v.getName().matches("^RA.")))
{
// System.out.println("Warning: " + v.getName() + v.getStream() + " is never referenced");
fireTimedEvent(TRAFFICCONTROL_CONTROLLER_WARNING,
new Object[] {getId(), v.toString(EnumSet.of(PrintFlags.ID)) + " is never referenced"},
this.simulator.getSimulatorTime());
}
if (!v.isDetector())
{
if (!v.getFlags().contains(Flags.HAS_START_RULE))
{
// System.out.println("Warning: " + v.getName() + v.getStream() + " has no start rule");
fireTimedEvent(TRAFFICCONTROL_CONTROLLER_WARNING,
new Object[] {getId(), v.toString(EnumSet.of(PrintFlags.ID)) + " has no start rule"},
this.simulator.getSimulatorTime());
}
if ((!v.getFlags().contains(Flags.HAS_END_RULE)) && (!v.isTimer()))
{
// System.out.println("Warning: " + v.getName() + v.getStream() + " has no end rule");
fireTimedEvent(TRAFFICCONTROL_CONTROLLER_WARNING,
new Object[] {getId(), v.toString(EnumSet.of(PrintFlags.ID)) + " has no end rule"},
this.simulator.getSimulatorTime());
}
}
}
Network network = null;
try
{
network = ((OtsModelInterface) this.simulator.getModel()).getNetwork();
}
catch (ClassCastException e)
{
throw new SimRuntimeException("Model is not an OtsModelInterface");
}
ImmutableCollection trafficLights = network.getObjectMap(TrafficLight.class).values();
Map> trafficLightMap = new LinkedHashMap<>();
for (TrafficLight tl : trafficLights)
{
String trafficLightName = tl.getId();
if (trafficLightName.startsWith(getId()))
{
trafficLightName = trafficLightName.substring(getId().length());
if (trafficLightName.startsWith("."))
{
trafficLightName = trafficLightName.substring(1);
}
}
if (trafficLightName.substring(trafficLightName.length() - 2).startsWith("."))
{
trafficLightName = trafficLightName.substring(0, trafficLightName.length() - 2);
}
List list = trafficLightMap.get(trafficLightName);
if (null == list)
{
list = new ArrayList<>();
trafficLightMap.put(trafficLightName, list);
}
list.add(tl);
}
Map detectors = new LinkedHashMap<>();
// Look up all the start/end detector and collect their parents (the traffic light sensors)
for (StartEndDetector startEndDetector : network.getObjectMap(StartEndDetector.class).values())
{
TrafficLightDetector trafficLightSensor = startEndDetector.getParent();
detectors.put(trafficLightSensor.getId(), trafficLightSensor);
}
for (Variable variable : this.variables.values())
{
if (variable.isOutput())
{
if (variable.getValue() != 0)
{
for (TrafficLight trafficLight : variable.getTrafficLights())
{
trafficLight.setTrafficLightColor(variable.getColor());
}
}
int added = 0;
String name = String.format("%s%02d", variable.getName(), variable.getStream());
String digits = String.format("%02d", variable.getStream());
List matchingLights = trafficLightMap.get(digits);
if (null == matchingLights)
{
throw new TrafficControlException("No traffic light for stream " + digits + " found");
}
for (TrafficLight tl : matchingLights)
{
try
{
variable.addOutput(tl);
}
catch (TrafficControlException exception)
{
// CANNOT HAPPEN
exception.printStackTrace();
throw new SimRuntimeException(exception);
}
if (variable.getValue() != 0)
{
tl.setTrafficLightColor(variable.getColor());
}
added++;
}
if (0 == added)
{
throw new TrafficControlException("No traffic light found that matches output " + name + " and " + getId());
}
}
else if (variable.isDetector())
{
String name = variable.getName();
String subNumber = name.substring(name.length() - 1);
name = name.substring(0, name.length() - 1);
name = String.format("%s%02d", name, variable.getStream());
String digits = String.format("%02d", variable.getStream());
TrafficLightDetector tls = detectors.get("D" + digits + subNumber);
if (null == tls)
{
throw new TrafficControlException(
"No sensor found that matches " + name + " subNumber " + subNumber + " and " + getId());
}
variable.subscribeToDetector(tls);
if (null != this.stateDisplay)
{
// Lookup the detector
EventListener el =
this.stateDisplay.getDetectorImage(String.format("%02d.%s", variable.getStream(), subNumber));
if (null == el)
{
throw new TrafficControlException("Cannor find detector image matching variable " + variable);
}
// System.out.println("creating subscriptions to sensor " + tls);
tls.addListener(el, TrafficLightDetector.TRAFFIC_LIGHT_DETECTOR_TRIGGER_ENTRY_EVENT);
tls.addListener(el, TrafficLightDetector.TRAFFIC_LIGHT_DETECTOR_TRIGGER_EXIT_EVENT);
}
}
}
}
/**
* Construct the display of this TrafCOD machine and connect it to the displayed traffic lights and sensors to this TrafCOD
* machine.
* @param rules List<String>; the individual lines that specify the graphics file and the locations of the sensor and
* lights in the image
* @throws TrafficControlException when the tfg data is invalid
* @throws IOException when reading the background image fails
*/
private void addTrafCODDisplay(final List rules) throws TrafficControlException, IOException
{
boolean useFirstCoordinates = true;
int lineno = 0;
for (String line : rules)
{
lineno++;
String rule = line.trim();
if (rule.length() == 0)
{
continue;
}
String[] fields = rule.split("=");
if ("mapfile".contentEquals(fields[0]))
{
if (fields[1].matches("[Bb][Mm][Pp]|[Pp][Nn][Gg]$"))
{
useFirstCoordinates = false; // TODO really figure out which coordinates to use
}
// System.out.println("map file description is " + inputLine);
// Make a decent attempt at constructing the URL of the map file
}
else if ("light".equals(fields[0]))
{
// Extract the stream number
int streamNumber;
try
{
streamNumber = Integer.parseInt(fields[1].substring(0, 2));
}
catch (NumberFormatException nfe)
{
throw new TrafficControlException("Bad traffic light number in coordinates: " + rule);
}
// Extract the coordinates and create the image
TrafficLightImage tli =
new TrafficLightImage(this.stateDisplay, getCoordinates(fields[1].substring(3), useFirstCoordinates),
String.format("Traffic Light %02d", streamNumber));
for (Variable v : this.variablesInDefinitionOrder)
{
if (v.isOutput() && v.getStream() == streamNumber)
{
// TODO: coupling between traffic light and tli via pub/sub, not as direct output of control
//v.addOutput(tli);
}
}
}
else if ("detector".equals(fields[0]))
{
int detectorStream;
int detectorSubNumber;
try
{
detectorStream = Integer.parseInt(fields[1].substring(0, 2));
detectorSubNumber = Integer.parseInt(fields[1].substring(3, 4));
}
catch (NumberFormatException nfe)
{
throw new TrafficControlException("Cannot parse detector number in coordinates " + rule);
}
String detectorName = String.format("D%02d%d", detectorStream, detectorSubNumber);
Variable detectorVariable = this.variables.get(detectorName);
if (null == detectorVariable)
{
throw new TrafficControlException(
"coordinates defines detector " + detectorName + " which does not exist in the TrafCOD program");
}
// DetectorImage di =
new DetectorImage(this.stateDisplay, getCoordinates(fields[1].substring(5), useFirstCoordinates),
String.format("%02d.%d", detectorStream, detectorSubNumber),
String.format("Detector %02d.%d", detectorStream, detectorSubNumber));
}
else
{
throw new TrafficControlException("Cannot parse coordinates line " + lineno + "in \"" + line + "\"");
}
}
}
/**
* Extract two coordinates from a line of text.
* @param line String; the text
* @param useFirstCoordinates boolean; if true; process the first pair of integer values; if false; use the second pair of
* integer values
* @return Point2D
* @throws TrafficControlException when the coordinates could not be parsed
*/
private static Point2D getCoordinates(final String line, final boolean useFirstCoordinates) throws TrafficControlException
{
String work = line.replaceAll("[ ,\t]+", "\t").trim();
int x;
int y;
String[] fields = work.split("\t");
if (fields.length < (useFirstCoordinates ? 2 : 4))
{
throw new TrafficControlException("not enough fields in tfg line \"" + line + "\"");
}
try
{
x = Integer.parseInt(fields[useFirstCoordinates ? 0 : 2]);
y = Integer.parseInt(fields[useFirstCoordinates ? 1 : 3]);
}
catch (NumberFormatException nfe)
{
throw new TrafficControlException("Bad value in tfg line \"" + line + "\"");
}
return new Point2D.Double(x, y);
}
/**
* Decrement all running timers.
* @return int; the total number of timers that expired
* @throws TrafficControlException Should never happen
*/
private int decrementTimers() throws TrafficControlException
{
// System.out.println("Decrement running timers");
int changeCount = 0;
for (Variable v : this.variables.values())
{
if (v.isTimer() && v.getValue() > 0 && v.decrementTimer(this.currentTime10))
{
changeCount++;
}
}
return changeCount;
}
/**
* Reset the START, END and CHANGED flags of all timers. (These do not get reset during the normal rule evaluation phase.)
*/
private void resetTimerFlags()
{
for (Variable v : this.variablesInDefinitionOrder)
{
if (v.isTimer())
{
v.clearChangedFlag();
v.clearFlag(Flags.START);
v.clearFlag(Flags.END);
}
}
}
/**
* Evaluate all expressions until no more changes occur.
* @throws TrafficControlException when evaluation of a rule fails
* @throws SimRuntimeException when scheduling the next evaluation fails
*/
@SuppressWarnings("unused")
private void evalExprs() throws TrafficControlException, SimRuntimeException
{
fireTimedEvent(TrafficController.TRAFFICCONTROL_CONTROLLER_EVALUATING, new Object[] {getId()},
this.simulator.getSimulatorTime());
// System.out.println("evalExprs: time is " + EngineeringFormatter.format(this.simulator.getSimulatorTime().si));
// insert some delay for testing; without this the simulation runs too fast
// try
// {
// Thread.sleep(10);
// }
// catch (InterruptedException exception)
// {
// System.out.println("Sleep in evalExprs was interrupted");
// // exception.printStackTrace();
// }
// Contrary to the C++ builder version; this implementation decrements the times at the start of evalExprs
// By doing it before updating this.currentTime10; the debugging output should be very similar
decrementTimers();
this.currentTime10 = (int) (this.simulator.getSimulatorTime().si * 10);
int loop;
for (loop = 0; loop < this.maxLoopCount; loop++)
{
int changeCount = evalExpressionsOnce();
resetTimerFlags();
if (changeCount == 0)
{
break;
}
}
// System.out.println("Executed " + (loop + 1) + " iteration(s)");
if (loop >= this.maxLoopCount)
{
StringBuffer warningMessage = new StringBuffer();
warningMessage.append(String
.format("Control program did not settle to a final state in %d iterations; oscillating variables:", loop));
for (Variable v : this.variablesInDefinitionOrder)
{
if (v.getFlags().contains(Flags.CHANGED))
{
warningMessage.append(String.format(" %s%02d", v.getName(), v.getStream()));
}
}
fireTimedEvent(TrafficController.TRAFFICCONTROL_CONTROLLER_WARNING,
new Object[] {getId(), warningMessage.toString()}, this.simulator.getSimulatorTime());
}
this.simulator.scheduleEventRel(EVALUATION_INTERVAL, this, "evalExprs", null);
}
/**
* Evaluate all expressions and return the number of changed variables.
* @return int; the number of changed variables
* @throws TrafficControlException when evaluation of a rule fails
*/
private int evalExpressionsOnce() throws TrafficControlException
{
for (Variable variable : this.variables.values())
{
variable.clearChangedFlag();
}
int changeCount = 0;
for (Object[] rule : this.tokenisedRules)
{
if (evalRule(rule))
{
changeCount++;
}
}
return changeCount;
}
/**
* Evaluate a rule.
* @param rule Object[]; the tokenised rule
* @return boolean; true if the variable that is affected by the rule has changed; false if no variable was changed
* @throws TrafficControlException when evaluation of the rule fails
*/
private boolean evalRule(final Object[] rule) throws TrafficControlException
{
boolean result = false;
Token ruleType = (Token) rule[0];
Variable destination = (Variable) rule[1];
if (destination.isTimer())
{
if (destination.getFlags().contains(Flags.TIMEREXPIRED))
{
destination.clearFlag(Flags.TIMEREXPIRED);
destination.setFlag(Flags.END);
}
else if (destination.getFlags().contains(Flags.START) || destination.getFlags().contains(Flags.END))
{
destination.clearFlag(Flags.START);
destination.clearFlag(Flags.END);
destination.setFlag(Flags.CHANGED);
}
}
else
{
// Normal Variable or detector
if (Token.START_RULE == ruleType)
{
destination.clearFlag(Flags.START);
}
else if (Token.END_RULE == ruleType)
{
destination.clearFlag(Flags.END);
}
else
{
destination.clearFlag(Flags.START);
destination.clearFlag(Flags.END);
}
}
int currentValue = destination.getValue();
if (Token.START_RULE == ruleType && currentValue != 0 || Token.END == ruleType && currentValue == 0
|| Token.INIT_TIMER == ruleType && currentValue != 0)
{
return false; // Value cannot change from zero to nonzero or vice versa due to evaluating the expression
}
this.currentRule = rule;
this.currentToken = 2; // Point to first token of the RHS
this.stack.clear();
evalExpr(0);
if (this.currentToken < this.currentRule.length && Token.CLOSE_PAREN == this.currentRule[this.currentToken])
{
throw new TrafficControlException("Too many closing parentheses");
}
int resultValue = pop();
if (Token.END_RULE == ruleType)
{
// Invert the result
if (0 == resultValue)
{
resultValue = destination.getValue(); // preserve the current value
}
else
{
resultValue = 0;
}
}
if (resultValue != 0 && destination.getValue() == 0)
{
destination.setFlag(Flags.START);
}
else if (resultValue == 0 && destination.getValue() != 0)
{
destination.setFlag(Flags.END);
}
if (destination.isTimer())
{
if (resultValue != 0 && Token.END_RULE != ruleType)
{
if (0 == destination.getValue())
{
result = true;
}
int timerValue10 = destination.getTimerMax();
if (timerValue10 < 1)
{
// Cheat; ensure it will property expire on the next timer tick
timerValue10 = 1;
}
result = destination.setValue(timerValue10, this.currentTime10, new CausePrinter(rule), this);
}
else if (0 == resultValue && Token.END_RULE == ruleType && destination.getValue() != 0)
{
result = destination.setValue(0, this.currentTime10, new CausePrinter(rule), this);
}
}
else if (destination.getValue() != resultValue)
{
result = destination.setValue(resultValue, this.currentTime10, new CausePrinter(rule), this);
if (destination.isOutput())
{
fireTimedEvent(TRAFFIC_LIGHT_CHANGED, new Object[] {getId(), destination.getStream(), destination.getColor()},
getSimulator().getSimulatorAbsTime());
}
if (destination.isConflictGroup() && resultValue != 0)
{
int conflictGroupRank = destination.conflictGroupRank();
StringBuilder conflictGroupList = new StringBuilder();
for (Short stream : this.conflictGroups.get(conflictGroupRank))
{
if (conflictGroupList.length() > 0)
{
conflictGroupList.append(" ");
}
conflictGroupList.append(String.format("%02d", stream));
}
fireTimedEvent(TRAFFICCONTROL_CONFLICT_GROUP_CHANGED,
new Object[] {getId(), this.currentConflictGroup, conflictGroupList.toString()},
getSimulator().getSimulatorTime());
// System.out.println("Conflict group changed from " + this.currentConflictGroup + " to "
// + conflictGroupList.toString());
this.currentConflictGroup = conflictGroupList.toString();
}
}
return result;
}
/** Binding strength of relational operators. */
private static final int BIND_RELATIONAL_OPERATOR = 1;
/** Binding strength of addition and subtraction. */
private static final int BIND_ADDITION = 2;
/** Binding strength of multiplication and division. */
private static final int BIND_MULTIPLY = 3;
/** Binding strength of unary minus. */
private static final int BIND_UNARY_MINUS = 4;
/**
* Evaluate an expression.
* The methods evalExpr and evalRHS together evaluate an expression. This is done using recursion and a stack. The argument
* bindingStrength that is passed around is the binding strength of the last preceding pending operator. if a binary
* operator with the same or a lower strength is encountered, the pending operator must be applied first. On the other hand
* of a binary operator with higher binding strength is encountered, that operator takes precedence over the pending
* operator. To evaluate an expression, call evalExpr with a bindingStrength value of 0. On return verify that currentToken
* has incremented to the end of the expression and that there is one value (the result) on the stack.
* @param bindingStrength int; the binding strength of a not yet applied binary operator (higher value must be applied
* first)
* @throws TrafficControlException when the expression is not valid
*/
private void evalExpr(final int bindingStrength) throws TrafficControlException
{
if (this.currentToken >= this.currentRule.length)
{
throw new TrafficControlException("Missing operand at end of expression " + printRule(this.currentRule, false));
}
Token token = (Token) this.currentRule[this.currentToken++];
Object nextToken = null;
if (this.currentToken < this.currentRule.length)
{
nextToken = this.currentRule[this.currentToken];
}
switch (token)
{
case UNARY_MINUS:
if (Token.OPEN_PAREN != nextToken && Token.VARIABLE != nextToken && Token.NEG_VARIABLE != nextToken
&& Token.CONSTANT != nextToken && Token.START != nextToken && Token.END != nextToken)
{
throw new TrafficControlException("Operand expected after unary minus");
}
evalExpr(BIND_UNARY_MINUS);
push(-pop());
break;
case OPEN_PAREN:
evalExpr(0);
if (Token.CLOSE_PAREN != this.currentRule[this.currentToken])
{
throw new TrafficControlException("Missing closing parenthesis");
}
this.currentToken++;
break;
case START:
if (Token.VARIABLE != nextToken || this.currentToken >= this.currentRule.length - 1)
{
throw new TrafficControlException("Missing variable after S");
}
nextToken = this.currentRule[++this.currentToken];
if (!(nextToken instanceof Variable))
{
throw new TrafficControlException("Missing variable after S");
}
push(((Variable) nextToken).getFlags().contains(Flags.START) ? 1 : 0);
this.currentToken++;
break;
case END:
if (Token.VARIABLE != nextToken || this.currentToken >= this.currentRule.length - 1)
{
throw new TrafficControlException("Missing variable after E");
}
nextToken = this.currentRule[++this.currentToken];
if (!(nextToken instanceof Variable))
{
throw new TrafficControlException("Missing variable after E");
}
push(((Variable) nextToken).getFlags().contains(Flags.END) ? 1 : 0);
this.currentToken++;
break;
case VARIABLE:
{
Variable operand = (Variable) nextToken;
if (operand.isTimer())
{
push(operand.getValue() == 0 ? 0 : 1);
}
else
{
push(operand.getValue());
}
this.currentToken++;
break;
}
case CONSTANT:
push((Integer) nextToken);
this.currentToken++;
break;
case NEG_VARIABLE:
Variable operand = (Variable) nextToken;
push(operand.getValue() == 0 ? 1 : 0);
this.currentToken++;
break;
default:
throw new TrafficControlException("Operand missing");
}
evalRHS(bindingStrength);
}
/**
* Evaluate the right-hand-side of an expression.
* @param bindingStrength int; the binding strength of the most recent, not yet applied, binary operator
* @throws TrafficControlException when the RHS of an expression is invalid
*/
private void evalRHS(final int bindingStrength) throws TrafficControlException
{
while (true)
{
if (this.currentToken >= this.currentRule.length)
{
return;
}
Token token = (Token) this.currentRule[this.currentToken];
switch (token)
{
case CLOSE_PAREN:
return;
case TIMES:
if (BIND_MULTIPLY <= bindingStrength)
{
return; // apply pending operator now
}
/*-
* apply pending operator later
* 1: evaluate the RHS operand.
* 2: multiply the top-most two operands on the stack and push the result on the stack.
*/
this.currentToken++;
evalExpr(BIND_MULTIPLY);
push(pop() * pop() == 0 ? 0 : 1);
break;
case EQ:
case NOTEQ:
case LE:
case LEEQ:
case GT:
case GTEQ:
if (BIND_RELATIONAL_OPERATOR <= bindingStrength)
{
return; // apply pending operator now
}
/*-
* apply pending operator later
* 1: evaluate the RHS operand.
* 2: compare the top-most two operands on the stack and push the result on the stack.
*/
this.currentToken++;
evalExpr(BIND_RELATIONAL_OPERATOR);
switch (token)
{
case EQ:
push(pop() == pop() ? 1 : 0);
break;
case NOTEQ:
push(pop() != pop() ? 1 : 0);
break;
case GT:
push(pop() < pop() ? 1 : 0);
break;
case GTEQ:
push(pop() <= pop() ? 1 : 0);
break;
case LE:
push(pop() > pop() ? 1 : 0);
break;
case LEEQ:
push(pop() >= pop() ? 1 : 0);
break;
default:
throw new TrafficControlException("Bad relational operator");
}
break;
case PLUS:
if (BIND_ADDITION <= bindingStrength)
{
return; // apply pending operator now
}
/*-
* apply pending operator later
* 1: evaluate the RHS operand.
* 2: add (OR) the top-most two operands on the stack and push the result on the stack.
*/
this.currentToken++;
evalExpr(BIND_ADDITION);
push(pop() + pop() == 0 ? 0 : 1);
break;
case MINUS:
if (BIND_ADDITION <= bindingStrength)
{
return; // apply pending operator now
}
/*-
* apply pending operator later
* 1: evaluate the RHS operand.
* 2: subtract the top-most two operands on the stack and push the result on the stack.
*/
this.currentToken++;
evalExpr(BIND_ADDITION);
push(-pop() + pop());
break;
default:
throw new TrafficControlException("Missing binary operator");
}
}
}
/**
* Push a value on the evaluation stack.
* @param value int; the value to push on the evaluation stack
*/
private void push(final int value)
{
this.stack.add(value);
}
/**
* Remove the last not-yet-removed value from the evaluation stack and return it.
* @return int; the last non-yet-removed value on the evaluation stack
* @throws TrafficControlException when the stack is empty
*/
private int pop() throws TrafficControlException
{
if (this.stack.size() < 1)
{
throw new TrafficControlException("Stack empty");
}
return this.stack.remove(this.stack.size() - 1);
}
/**
* Print a tokenized rule.
* @param tokens Object[]; the tokens
* @param printValues boolean; if true; print the values of all encountered variable; if false; do not print the values of
* all encountered variable
* @return String; a textual approximation of the original rule
* @throws TrafficControlException when tokens does not match the expected grammar
*/
static String printRule(final Object[] tokens, final boolean printValues) throws TrafficControlException
{
EnumSet variableFlags = EnumSet.of(PrintFlags.ID);
if (printValues)
{
variableFlags.add(PrintFlags.VALUE);
}
EnumSet negatedVariableFlags = EnumSet.copyOf(variableFlags);
negatedVariableFlags.add(PrintFlags.NEGATED);
StringBuilder result = new StringBuilder();
for (int inPos = 0; inPos < tokens.length; inPos++)
{
Object token = tokens[inPos];
if (token instanceof Token)
{
switch ((Token) token)
{
case EQUALS_RULE:
result.append(((Variable) tokens[++inPos]).toString(variableFlags));
result.append("=");
break;
case NEG_EQUALS_RULE:
result.append(((Variable) tokens[++inPos]).toString(negatedVariableFlags));
result.append("=");
break;
case START_RULE:
result.append(((Variable) tokens[++inPos]).toString(variableFlags));
result.append(".=");
break;
case END_RULE:
result.append(((Variable) tokens[++inPos]).toString(variableFlags));
result.append("N.=");
break;
case INIT_TIMER:
result.append(((Variable) tokens[++inPos]).toString(EnumSet.of(PrintFlags.ID, PrintFlags.INITTIMER)));
result.append(".=");
break;
case REINIT_TIMER:
result.append(((Variable) tokens[++inPos]).toString(EnumSet.of(PrintFlags.ID, PrintFlags.REINITTIMER)));
result.append(".=");
break;
case START:
result.append("S");
break;
case END:
result.append("E");
break;
case VARIABLE:
result.append(((Variable) tokens[++inPos]).toString(variableFlags));
break;
case NEG_VARIABLE:
result.append(((Variable) tokens[++inPos]).toString(variableFlags));
result.append("N");
break;
case CONSTANT:
result.append(tokens[++inPos]).toString();
break;
case UNARY_MINUS:
case MINUS:
result.append("-");
break;
case PLUS:
result.append("+");
break;
case TIMES:
result.append(".");
break;
case EQ:
result.append("=");
break;
case NOTEQ:
result.append("<>");
break;
case GT:
result.append(">");
break;
case GTEQ:
result.append(">=");
break;
case LE:
result.append("<");
break;
case LEEQ:
result.append("<=");
break;
case OPEN_PAREN:
result.append("(");
break;
case CLOSE_PAREN:
result.append(")");
break;
default:
System.out.println(
"<<>> encountered a non-Token object: " + token + " after " + result.toString());
throw new TrafficControlException("Unknown token");
}
}
else
{
System.out.println("<<>> encountered a non-Token object: " + token + " after " + result.toString());
throw new TrafficControlException("Not a token");
}
}
return result.toString();
}
/**
* States of the rule parser.
* @author Peter Knoppers
*/
enum ParserState
{
/** Looking for the left hand side of an assignment. */
FIND_LHS,
/** Looking for an assignment operator. */
FIND_ASSIGN,
/** Looking for the right hand side of an assignment. */
FIND_RHS,
/** Looking for an optional unary minus. */
MAY_UMINUS,
/** Looking for an expression. */
FIND_EXPR,
}
/**
* Types of TrafCOD tokens.
* @author Peter Knoppers
*/
enum Token
{
/** Equals rule. */
EQUALS_RULE,
/** Not equals rule. */
NEG_EQUALS_RULE,
/** Assignment rule. */
ASSIGNMENT,
/** Start rule. */
START_RULE,
/** End rule. */
END_RULE,
/** Timer initialize rule. */
INIT_TIMER,
/** Timer re-initialize rule. */
REINIT_TIMER,
/** Unary minus operator. */
UNARY_MINUS,
/** Less than or equal to (<=). */
LEEQ,
/** Not equal to (!=). */
NOTEQ,
/** Less than (<). */
LE,
/** Greater than or equal to (>=). */
GTEQ,
/** Greater than (>). */
GT,
/** Equals to (=). */
EQ,
/** True if following variable has just started. */
START,
/** True if following variable has just ended. */
END,
/** Variable follows. */
VARIABLE,
/** Variable that follows must be logically negated. */
NEG_VARIABLE,
/** Integer follows. */
CONSTANT,
/** Addition operator. */
PLUS,
/** Subtraction operator. */
MINUS,
/** Multiplication operator. */
TIMES,
/** Opening parenthesis. */
OPEN_PAREN,
/** Closing parenthesis. */
CLOSE_PAREN,
}
/**
* Parse one TrafCOD rule.
* @param rawRule String; the TrafCOD rule
* @param locationDescription String; description of the location (file, line) where the rule was found
* @return Object[]; array filled with the tokenized rule
* @throws TrafficControlException when the rule is not a valid TrafCOD rule
*/
private Object[] parse(final String rawRule, final String locationDescription) throws TrafficControlException
{
if (rawRule.length() == 0)
{
throw new TrafficControlException("empty rule at " + locationDescription);
}
ParserState state = ParserState.FIND_LHS;
String rule = rawRule.toUpperCase(Locale.US);
Token ruleType = Token.ASSIGNMENT;
int inPos = 0;
NameAndStream lhsNameAndStream = null;
List