DefinitionsParser.java

  1. package org.opentrafficsim.road.network.factory.xml.parser;

  3. import java.util.LinkedHashMap;
  4. import java.util.Map;

  6. import org.djunits.value.vdouble.scalar.Speed;
  7. import org.djutils.logger.CategoryLogger;
  8. import org.opentrafficsim.base.logger.Cat;
  9. import org.opentrafficsim.base.parameters.ParameterType;
  10. import org.opentrafficsim.core.compatibility.GTUCompatibility;
  11. import org.opentrafficsim.core.gtu.GTUType;
  12. import org.opentrafficsim.core.network.LinkType;
  13. import org.opentrafficsim.core.network.LongitudinalDirectionality;
  14. import org.opentrafficsim.road.network.OTSRoadNetwork;
  15. import org.opentrafficsim.road.network.factory.xml.XmlParserException;
  16. import org.opentrafficsim.road.network.factory.xml.utils.ParseUtil;
  17. import org.opentrafficsim.road.network.lane.LaneType;
  18. import org.opentrafficsim.xml.generated.COMPATIBILITY;
  19. import org.opentrafficsim.xml.generated.DEFINITIONS;
  20. import org.opentrafficsim.xml.generated.GTUTEMPLATE;
  21. import org.opentrafficsim.xml.generated.GTUTEMPLATES;
  22. import org.opentrafficsim.xml.generated.GTUTYPE;
  23. import org.opentrafficsim.xml.generated.GTUTYPES;
  24. import org.opentrafficsim.xml.generated.LANETYPE;
  25. import org.opentrafficsim.xml.generated.LANETYPES;
  26. import org.opentrafficsim.xml.generated.LINKTYPE;
  27. import org.opentrafficsim.xml.generated.LINKTYPES;
  28. import org.opentrafficsim.xml.generated.PARAMETERTYPE;
  29. import org.opentrafficsim.xml.generated.ROADLAYOUT;
  30. import org.opentrafficsim.xml.generated.ROADLAYOUTS;
  31. import org.opentrafficsim.xml.generated.SPEEDLIMIT;

  33. import nl.tudelft.simulation.dsol.experiment.StreamInformation;

  35. /**
  36.  * DefinitionParser parses the XML nodes of the DEFINITIONS tag: GTUTYPE, GTUTEMPLATE, LINKTYPE, LANETYPE and ROADLAYOUT. <br>
  37.  * <br>
  38.  * Copyright (c) 2003-2022 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See
  39.  * for project information <a href="https://www.simulation.tudelft.nl/" target="_blank">www.simulation.tudelft.nl</a>. The
  40.  * source code and binary code of this software is proprietary information of Delft University of Technology.
  41.  * @author <a href="https://www.tudelft.nl/averbraeck" target="_blank">Alexander Verbraeck</a>
  42.  */
  43. public final class DefinitionsParser
  44. {
  45.     /** */
  46.     private DefinitionsParser()
  47.     {
  48.         // utility class
  49.     }

  51.     /**
  52.      * Parse the DEFINITIONS tag in the OTS XML file.
  53.      * @param otsNetwork the network
  54.      * @param definitions the DEFINTIONS tag
  55.      * @param overwriteDefaults overwrite default definitions in otsNetwork or not
  56.      * @param roadLayoutMap temporary storage for the road layouts
  57.      * @param gtuTemplates map of GTU templates for the OD and/or Generators
  58.      * @param streamInformation map with stream information 
  59.      * @param linkTypeSpeedLimitMap map with speed limit information per link type
  60.      * @throws XmlParserException on parsing error
  61.      */
  62.     public static void parseDefinitions(final OTSRoadNetwork otsNetwork, final DEFINITIONS definitions,
  63.             final boolean overwriteDefaults, final Map<String, ROADLAYOUT> roadLayoutMap,
  64.             final Map<String, GTUTEMPLATE> gtuTemplates, final StreamInformation streamInformation,
  65.             final Map<LinkType, Map<GTUType, Speed>> linkTypeSpeedLimitMap) throws XmlParserException
  66.     {
  67.         parseGtuTypes(definitions, otsNetwork, overwriteDefaults);
  68.         parseLinkTypes(definitions, otsNetwork, overwriteDefaults, linkTypeSpeedLimitMap);
  69.         parseLaneTypes(definitions, otsNetwork, overwriteDefaults);
  70.         parseGtuTemplates(definitions, otsNetwork, overwriteDefaults, gtuTemplates, streamInformation);
  71.         parseRoadLayouts(definitions, otsNetwork, roadLayoutMap);
  72.     }

  74.     /**
  75.      * Parse the GTUTYPES tag in the OTS XML file.
  76.      * @param definitions the DEFINTIONS tag
  77.      * @param otsNetwork the network
  78.      * @param overwriteDefaults overwrite default definitions in otsNetwork or not
  79.      * @throws XmlParserException on parsing error
  80.      */
  81.     public static void parseGtuTypes(final DEFINITIONS definitions, final OTSRoadNetwork otsNetwork,
  82.             final boolean overwriteDefaults) throws XmlParserException
  83.     {
  84.         for (GTUTYPES gtuTypes : ParseUtil.getObjectsOfType(definitions.getIncludeAndGTUTYPESAndGTUTEMPLATES(), GTUTYPES.class))
  85.         {
  86.             for (GTUTYPE gtuTag : gtuTypes.getGTUTYPE())
  87.             {
  88.                 GTUType networkGtuType = otsNetwork.getGtuTypes().get(gtuTag.getID());
  89.                 if (networkGtuType == null || (networkGtuType != null && !gtuTag.isDEFAULT())
  90.                         || (networkGtuType != null && gtuTag.isDEFAULT() && overwriteDefaults))
  91.                 {
  92.                     if (gtuTag.getPARENT() != null)
  93.                     {
  94.                         GTUType parent = otsNetwork.getGtuType(gtuTag.getPARENT());
  95.                         if (parent == null)
  96.                         {
  97.                             throw new XmlParserException(
  98.                                     "GTUType " + gtuTag.getID() + " parent " + gtuTag.getPARENT() + " not found");
  99.                         }
  100.                         GTUType gtuType = new GTUType(gtuTag.getID(), parent);
  101.                         CategoryLogger.filter(Cat.PARSER).trace("Added GTUType {}", gtuType);
  102.                     }
  103.                     else
  104.                     {
  105.                         GTUType gtuType = new GTUType(gtuTag.getID(), otsNetwork);
  106.                         CategoryLogger.filter(Cat.PARSER).trace("Added GTUType {}", gtuType);
  107.                     }
  108.                 }
  109.                 else
  110.                     CategoryLogger.filter(Cat.PARSER).trace("Did NOT add GTUType {}", gtuTag.getID());
  111.             }
  112.         }
  113.     }

  115.     /**
  116.      * Parse the LINKTYPES tag in the OTS XML file.
  117.      * @param definitions the DEFINTIONS tag
  118.      * @param otsNetwork the network
  119.      * @param overwriteDefaults overwrite default definitions in otsNetwork or not
  120.      * @param linkTypeSpeedLimitMap map with speed limit information per link type
  121.      * @throws XmlParserException on parsing error
  122.      */
  123.     public static void parseLinkTypes(final DEFINITIONS definitions, final OTSRoadNetwork otsNetwork,
  124.             final boolean overwriteDefaults, final Map<LinkType, Map<GTUType, Speed>> linkTypeSpeedLimitMap)
  125.             throws XmlParserException
  126.     {
  127.         for (LINKTYPES linkTypes : ParseUtil.getObjectsOfType(definitions.getIncludeAndGTUTYPESAndGTUTEMPLATES(),
  128.                 LINKTYPES.class))
  129.         {
  130.             for (LINKTYPE linkTag : linkTypes.getLINKTYPE())
  131.             {
  132.                 LinkType networkLinkType = otsNetwork.getLinkTypes().get(linkTag.getID());
  133.                 if (networkLinkType == null || (networkLinkType != null && !linkTag.isDEFAULT())
  134.                         || (networkLinkType != null && linkTag.isDEFAULT() && overwriteDefaults))
  135.                 {
  136.                     GTUCompatibility<LinkType> compatibility = new GTUCompatibility<>((LinkType) null);
  137.                     for (COMPATIBILITY compTag : linkTag.getCOMPATIBILITY())
  138.                     {
  139.                         GTUType gtuType = otsNetwork.getGtuType(compTag.getGTUTYPE());
  140.                         if (gtuType == null)
  141.                         {
  142.                             throw new XmlParserException("LinkType " + linkTag.getID() + ".compatibility: GTUType "
  143.                                     + compTag.getGTUTYPE() + " not found");
  144.                         }
  145.                         compatibility.addAllowedGTUType(gtuType,
  146.                                 LongitudinalDirectionality.valueOf(compTag.getDIRECTION().toString()));
  147.                     }
  148.                     LinkType parent = otsNetwork.getLinkType(linkTag.getPARENT());
  149.                     LinkType linkType = new LinkType(linkTag.getID(), parent, compatibility, otsNetwork);
  150.                     networkLinkType = linkType;
  151.                     CategoryLogger.filter(Cat.PARSER).trace("Added LinkType {}", linkType);
  152.                 }
  153.                 else
  154.                 {
  155.                     CategoryLogger.filter(Cat.PARSER).trace("Did NOT add LinkType {}", linkTag.getID());
  156.                 }

  158.                 linkTypeSpeedLimitMap.put(networkLinkType, new LinkedHashMap<>());
  159.                 for (SPEEDLIMIT speedLimitTag : linkTag.getSPEEDLIMIT())
  160.                 {
  161.                     GTUType gtuType = otsNetwork.getGtuType(speedLimitTag.getGTUTYPE());
  162.                     linkTypeSpeedLimitMap.get(networkLinkType).put(gtuType, speedLimitTag.getLEGALSPEEDLIMIT());
  163.                 }
  164.             }
  165.         }
  166.     }

  168.     /**
  169.      * Parse the LANETYPES tag in the OTS XML file.
  170.      * @param definitions the DEFINTIONS tag
  171.      * @param otsNetwork the network
  172.      * @param overwriteDefaults overwrite default definitions in otsNetwork or not
  173.      * @throws XmlParserException on parsing error
  174.      */
  175.     public static void parseLaneTypes(final DEFINITIONS definitions, final OTSRoadNetwork otsNetwork,
  176.             final boolean overwriteDefaults) throws XmlParserException
  177.     {
  178.         for (LANETYPES laneTypes : ParseUtil.getObjectsOfType(definitions.getIncludeAndGTUTYPESAndGTUTEMPLATES(),
  179.                 LANETYPES.class))
  180.         {
  181.             for (LANETYPE laneTag : laneTypes.getLANETYPE())
  182.             {
  183.                 LaneType networkLaneType = otsNetwork.getLaneTypes().get(laneTag.getID());
  184.                 if (networkLaneType == null || (networkLaneType != null && !laneTag.isDEFAULT())
  185.                         || (networkLaneType != null && laneTag.isDEFAULT() && overwriteDefaults))
  186.                 {
  187.                     GTUCompatibility<LaneType> compatibility = new GTUCompatibility<>((LaneType) null);
  188.                     for (COMPATIBILITY compTag : laneTag.getCOMPATIBILITY())
  189.                     {
  190.                         GTUType gtuType = otsNetwork.getGtuType(compTag.getGTUTYPE());
  191.                         if (gtuType == null)
  192.                         {
  193.                             throw new XmlParserException("LaneType " + laneTag.getID() + ".compatibility: GTUType "
  194.                                     + compTag.getGTUTYPE() + " not found");
  195.                         }
  196.                         compatibility.addAllowedGTUType(gtuType,
  197.                                 LongitudinalDirectionality.valueOf(compTag.getDIRECTION().toString()));
  198.                     }
  199.                     if (laneTag.getPARENT() != null)
  200.                     {
  201.                         LaneType parent = otsNetwork.getLaneType(laneTag.getPARENT());
  202.                         if (parent == null)
  203.                         {
  204.                             throw new XmlParserException(
  205.                                     "LaneType " + laneTag.getID() + " parent " + laneTag.getPARENT() + " not found");
  206.                         }
  207.                         LaneType laneType = new LaneType(laneTag.getID(), parent, compatibility, otsNetwork);
  208.                         CategoryLogger.filter(Cat.PARSER).trace("Added LaneType {}", laneType);
  209.                     }
  210.                     else
  211.                     {
  212.                         LaneType laneType = new LaneType(laneTag.getID(), compatibility, otsNetwork);
  213.                         CategoryLogger.filter(Cat.PARSER).trace("Added LaneType {}", laneType);
  214.                     }
  215.                 }
  216.                 else
  217.                     CategoryLogger.filter(Cat.PARSER).trace("Did NOT add LaneType {}", laneTag.getID());
  218.             }
  219.         }
  220.     }

  222.     /**
  223.      * Store the GTUTEMPLATE tags in the OTS XML file.
  224.      * @param definitions the DEFINTIONS tag
  225.      * @param otsNetwork the network
  226.      * @param overwriteDefaults overwrite default definitions in otsNetwork or not
  227.      * @param gtuTemplates the templates to be used in the OD/Generators
  228.      * @param streamInformation map with stream information
  229.      * @throws XmlParserException on parsing error
  230.      */
  231.     public static void parseGtuTemplates(final DEFINITIONS definitions, final OTSRoadNetwork otsNetwork,
  232.             final boolean overwriteDefaults, final Map<String, GTUTEMPLATE> gtuTemplates,
  233.             final StreamInformation streamInformation)
  234.             throws XmlParserException
  235.     {
  236.         for (GTUTEMPLATES templateTypes : ParseUtil.getObjectsOfType(definitions.getIncludeAndGTUTYPESAndGTUTEMPLATES(),
  237.                 GTUTEMPLATES.class))
  238.         {
  239.             for (GTUTEMPLATE templateTag : templateTypes.getGTUTEMPLATE())
  240.             {
  241.                 GTUType gtuType = otsNetwork.getGtuType(templateTag.getGTUTYPE());
  242.                 if (gtuType == null)
  243.                 {
  244.                     throw new XmlParserException(
  245.                             "GTUTemplate " + templateTag.getID() + " GTUType " + templateTag.getGTUTYPE() + " not found");
  246.                 }
  247.                 gtuTemplates.put(templateTag.getID(), templateTag);
  248.             }
  249.         }
  250.     }

  252.     /**
  253.      * Parse the ROADLAYOUTS tag in the OTS XML file.
  254.      * @param definitions the DEFINTIONS tag
  255.      * @param otsNetwork the network
  256.      * @param roadLayoutMap temporary storage for the road layouts
  257.      * @throws XmlParserException on parsing error
  258.      */
  259.     public static void parseRoadLayouts(final DEFINITIONS definitions, final OTSRoadNetwork otsNetwork,
  260.             final Map<String, ROADLAYOUT> roadLayoutMap) throws XmlParserException
  261.     {
  262.         for (ROADLAYOUTS roadLayoutTypes : ParseUtil.getObjectsOfType(definitions.getIncludeAndGTUTYPESAndGTUTEMPLATES(),
  263.                 ROADLAYOUTS.class))
  264.         {
  265.             for (ROADLAYOUT layoutTag : roadLayoutTypes.getROADLAYOUT())
  266.             {
  267.                 roadLayoutMap.put(layoutTag.getID(), layoutTag);
  268.             }
  269.         }
  270.     }

  272.     /**
  273.      * Parse the PARAMETERTYPE tags in the OTS XML file.
  274.      * @param definitions the DEFINTIONS tag
  275.      * @param otsNetwork the network
  276.      * @param parameterMap map to store parameter type by id
  277.      * @throws XmlParserException if the field in a PARAMETERTYPE does not refer to a ParameterType&lt;?&gt;
  278.      */
  279.     public static void parseParameterTypes(final DEFINITIONS definitions, final OTSRoadNetwork otsNetwork,
  280.             final Map<String, ParameterType<?>> parameterMap) throws XmlParserException
  281.     {
  282.         for (PARAMETERTYPE parameterType : ParseUtil.getObjectsOfType(definitions.getIncludeAndGTUTYPESAndGTUTEMPLATES(),
  283.                 PARAMETERTYPE.class))
  284.         {
  285.             try
  286.             {
  287.                 parameterMap.put(parameterType.getID(), (ParameterType<?>) parameterType.getFIELD());
  288.             }
  289.             catch (ClassCastException exception)
  290.             {
  291.                 throw new XmlParserException("Parameter type with id " + parameterType.getID()
  292.                         + " refers to a static field that is not a ParameterType<?>.");
  293.             }
  294.         }
  295.     }

  297. }
Created with JaCoCo 0.8.6.202009150832