Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file DataHandler.cpp
15 : /// @author Jakob Erdmann
16 : /// @date Jun 2021
17 : ///
18 : // The XML-Handler for data elements loading
19 : /****************************************************************************/
20 : #include <config.h>
21 :
22 : #include <utils/common/MsgHandler.h>
23 : #include <utils/common/StringUtils.h>
24 : #include <utils/xml/XMLSubSys.h>
25 :
26 : #include "DataHandler.h"
27 :
28 :
29 : // ===========================================================================
30 : // method definitions
31 : // ===========================================================================
32 :
33 0 : DataHandler::DataHandler(const std::string& file) :
34 0 : SUMOSAXHandler(file) {
35 0 : }
36 :
37 :
38 0 : DataHandler::~DataHandler() {}
39 :
40 :
41 : bool
42 0 : DataHandler::parse() {
43 : // run parser and return result
44 0 : return XMLSubSys::runParser(*this, getFileName());
45 : }
46 :
47 :
48 : void
49 0 : DataHandler::parseSumoBaseObject(CommonXMLStructure::SumoBaseObject* obj) {
50 : // switch tag
51 0 : switch (obj->getTag()) {
52 : // Stopping Places
53 0 : case SUMO_TAG_INTERVAL:
54 0 : buildDataInterval(obj,
55 : obj->getStringAttribute(SUMO_ATTR_ID),
56 : obj->getDoubleAttribute(SUMO_ATTR_BEGIN),
57 : obj->getDoubleAttribute(SUMO_ATTR_END));
58 0 : break;
59 0 : case SUMO_TAG_EDGE:
60 0 : buildEdgeData(obj,
61 : obj->getStringAttribute(SUMO_ATTR_ID),
62 0 : obj->getParameters());
63 0 : break;
64 0 : case SUMO_TAG_EDGEREL:
65 0 : buildEdgeRelationData(obj,
66 : obj->getStringAttribute(SUMO_ATTR_FROM),
67 : obj->getStringAttribute(SUMO_ATTR_TO),
68 0 : obj->getParameters());
69 0 : break;
70 0 : case SUMO_TAG_TAZREL:
71 0 : buildTAZRelationData(obj,
72 : obj->getStringAttribute(SUMO_ATTR_FROM),
73 : obj->getStringAttribute(SUMO_ATTR_TO),
74 0 : obj->getParameters());
75 0 : break;
76 : default:
77 : break;
78 : }
79 : // now iterate over childrens
80 0 : for (const auto& child : obj->getSumoBaseObjectChildren()) {
81 : // call this function recursively
82 0 : parseSumoBaseObject(child);
83 : }
84 0 : }
85 :
86 :
87 : void
88 0 : DataHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
89 : // obtain tag
90 : const SumoXMLTag tag = (element == 0) ? SUMO_TAG_ROOTFILE : static_cast<SumoXMLTag>(element);
91 : // open SUMOBaseOBject
92 0 : myCommonXMLStructure.openSUMOBaseOBject();
93 : // check tag
94 : try {
95 0 : switch (tag) {
96 : // interval
97 0 : case SUMO_TAG_INTERVAL:
98 0 : parseInterval(attrs);
99 : break;
100 : // datas
101 0 : case SUMO_TAG_EDGE:
102 0 : parseEdgeData(attrs);
103 : break;
104 0 : case SUMO_TAG_EDGEREL:
105 0 : parseEdgeRelationData(attrs);
106 : break;
107 0 : case SUMO_TAG_TAZREL:
108 0 : parseTAZRelationData(attrs);
109 : break;
110 0 : case SUMO_TAG_PARAM:
111 0 : WRITE_WARNING(TL("Data elements cannot load attributes as params"));
112 0 : myCommonXMLStructure.abortSUMOBaseOBject();
113 : break;
114 0 : default:
115 : // tag cannot be parsed in routeHandler
116 0 : myCommonXMLStructure.abortSUMOBaseOBject();
117 : break;
118 : }
119 0 : } catch (InvalidArgument& e) {
120 0 : writeError(e.what());
121 0 : }
122 0 : }
123 :
124 :
125 : void
126 0 : DataHandler::myEndElement(int element) {
127 : // obtain tag
128 : const SumoXMLTag tag = static_cast<SumoXMLTag>(element);
129 : // get last inserted object
130 0 : CommonXMLStructure::SumoBaseObject* obj = myCommonXMLStructure.getCurrentSumoBaseObject();
131 : // close SUMOBaseOBject
132 0 : myCommonXMLStructure.closeSUMOBaseOBject();
133 : // check tag
134 0 : switch (tag) {
135 : // only interval
136 0 : case SUMO_TAG_INTERVAL:
137 : // parse object and all their childrens
138 0 : parseSumoBaseObject(obj);
139 : // delete object (and all of their childrens)
140 0 : delete obj;
141 : break;
142 : default:
143 : break;
144 : }
145 0 : }
146 :
147 :
148 : bool
149 0 : DataHandler::isErrorCreatingElement() const {
150 0 : return myErrorCreatingElement;
151 : }
152 :
153 :
154 : void
155 0 : DataHandler::writeError(const std::string& error) {
156 0 : WRITE_ERROR(error);
157 0 : myErrorCreatingElement = true;
158 0 : }
159 :
160 :
161 : void
162 0 : DataHandler::parseInterval(const SUMOSAXAttributes& attrs) {
163 : // declare Ok Flag
164 0 : bool parsedOk = true;
165 : // needed attributes
166 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
167 0 : const double begin = attrs.get<double>(SUMO_ATTR_BEGIN, "", parsedOk);
168 0 : const double end = attrs.get<double>(SUMO_ATTR_END, "", parsedOk);
169 : // continue if flag is ok
170 0 : if (parsedOk) {
171 : // set tag
172 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INTERVAL);
173 : // add all attributes
174 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
175 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_BEGIN, begin);
176 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_END, end);
177 : }
178 0 : }
179 :
180 :
181 : void
182 0 : DataHandler::parseEdgeData(const SUMOSAXAttributes& attrs) {
183 : // declare Ok Flag
184 0 : bool parsedOk = true;
185 : // needed attributes
186 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
187 : // fill attributes
188 0 : getAttributes(attrs, {SUMO_ATTR_ID});
189 : // continue if flag is ok
190 0 : if (parsedOk) {
191 : // set tag
192 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_EDGE);
193 : // add all attributes
194 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
195 : }
196 0 : }
197 :
198 :
199 : void
200 0 : DataHandler::parseEdgeRelationData(const SUMOSAXAttributes& attrs) {
201 : // declare Ok Flag
202 0 : bool parsedOk = true;
203 : // needed attributes
204 0 : const std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, "", parsedOk);
205 0 : const std::string to = attrs.get<std::string>(SUMO_ATTR_TO, "", parsedOk);
206 : // fill attributes
207 0 : getAttributes(attrs, {SUMO_ATTR_FROM, SUMO_ATTR_TO});
208 : // continue if flag is ok
209 0 : if (parsedOk) {
210 : // set tag
211 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_EDGEREL);
212 : // add all attributes
213 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FROM, from);
214 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TO, to);
215 : }
216 0 : }
217 :
218 :
219 : void
220 0 : DataHandler::parseTAZRelationData(const SUMOSAXAttributes& attrs) {
221 : // declare Ok Flag
222 0 : bool parsedOk = true;
223 : // needed attributes
224 0 : const std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, "", parsedOk);
225 0 : const std::string to = attrs.get<std::string>(SUMO_ATTR_TO, "", parsedOk);
226 : // fill attributes
227 0 : getAttributes(attrs, {SUMO_ATTR_FROM, SUMO_ATTR_TO});
228 : // continue if flag is ok
229 0 : if (parsedOk) {
230 : // set tag
231 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZREL);
232 : // add all attributes
233 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FROM, from);
234 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TO, to);
235 : }
236 0 : }
237 :
238 :
239 : void
240 0 : DataHandler::getAttributes(const SUMOSAXAttributes& attrs, const std::vector<SumoXMLAttr> avoidAttributes) const {
241 : // transform avoidAttributes to strings
242 : std::vector<std::string> avoidAttributesStr;
243 0 : for (const SumoXMLAttr& avoidAttribute : avoidAttributes) {
244 0 : avoidAttributesStr.push_back(toString(avoidAttribute));
245 : }
246 : // iterate over attributes and fill parameters map
247 0 : for (const std::string& attribute : attrs.getAttributeNames()) {
248 0 : if (std::find(avoidAttributesStr.begin(), avoidAttributesStr.end(), attribute) == avoidAttributesStr.end()) {
249 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addParameter(attribute, attrs.getStringSecure(attribute, ""));
250 : }
251 0 : }
252 0 : }
253 :
254 :
255 : void
256 0 : DataHandler::checkParent(const SumoXMLTag currentTag, const SumoXMLTag parentTag, bool& ok) {
257 : // check that parent SUMOBaseObject's tag is the parentTag
258 0 : if ((myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject() &&
259 0 : (myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject()->getTag() == parentTag)) == false) {
260 0 : writeError(toString(currentTag) + " must be defined within the definition of a " + toString(parentTag));
261 0 : ok = false;
262 : }
263 0 : }
264 :
265 : /****************************************************************************/
|
