Eclipse SUMO - Simulation of Urban MObility
GNEAttributeCarrier.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
14 // Abstract Base class for gui objects which carry attributes
15 /****************************************************************************/
16 
17 
18 // ===========================================================================
19 // included modules
20 // ===========================================================================
21 
29 
30 #include "GNEAttributeCarrier.h"
31 #include "GNENet.h"
32 
33 
34 // ===========================================================================
35 // static members
36 // ===========================================================================
37 
38 std::map<SumoXMLTag, GNEAttributeCarrier::TagProperties> GNEAttributeCarrier::myTagProperties;
40 
41 const std::string GNEAttributeCarrier::FEATURE_LOADED = "loaded";
42 const std::string GNEAttributeCarrier::FEATURE_GUESSED = "guessed";
43 const std::string GNEAttributeCarrier::FEATURE_MODIFIED = "modified";
44 const std::string GNEAttributeCarrier::FEATURE_APPROVED = "approved";
46 const double GNEAttributeCarrier::INVALID_POSITION(-1000000);
47 
48 
49 // ===========================================================================
50 // method definitions
51 // ===========================================================================
52 
53 // ---------------------------------------------------------------------------
54 // GNEAttributeCarrier::AttributeProperties - methods
55 // ---------------------------------------------------------------------------
56 
58  myAttribute(SUMO_ATTR_NOTHING),
59  myTagPropertyParent(nullptr),
60  myAttrStr(toString(SUMO_ATTR_NOTHING)),
61  myAttributeProperty(ATTRPROPERTY_STRING),
62  myDefinition(""),
63  myDefaultValue(""),
64  myAttrSynonym(SUMO_ATTR_NOTHING),
65  myMinimumRange(0),
66  myMaximumRange(0) {}
67 
68 
69 GNEAttributeCarrier::AttributeProperties::AttributeProperties(const SumoXMLAttr attribute, const int attributeProperty, const std::string& definition, std::string defaultValue) :
70  myAttribute(attribute),
71  myTagPropertyParent(nullptr),
72  myAttrStr(toString(attribute)),
73  myAttributeProperty(attributeProperty),
74  myDefinition(definition),
75  myDefaultValue(defaultValue),
76  myAttrSynonym(SUMO_ATTR_NOTHING),
77  myMinimumRange(0),
78  myMaximumRange(0) {
79  // empty definition aren't valid
80  if (definition.empty()) {
81  throw FormatException("Missing definition for AttributeProperty '" + toString(attribute) + "'");
82  }
83  // if default value isn't empty, but attribute doesn't support default values, throw exception.
84  if (!defaultValue.empty() && !(attributeProperty & ATTRPROPERTY_DEFAULTVALUESTATIC)) {
85  throw FormatException("AttributeProperty for '" + toString(attribute) + "' doesn't support default values");
86  }
87  // default value cannot be static and mutables at the same time
88  if ((attributeProperty & ATTRPROPERTY_DEFAULTVALUESTATIC) && (attributeProperty & ATTRPROPERTY_DEFAULTVALUEMUTABLE)) {
89  throw FormatException("Default value for attribute '" + toString(attribute) + "' cannot be static and mutable at the same time");
90  }
91  // Attributes that can write optionally their values in XML must have either a static or a mutable efault value
92  if ((attributeProperty & ATTRPROPERTY_OPTIONAL) && !((attributeProperty & ATTRPROPERTY_DEFAULTVALUESTATIC) || (attributeProperty & ATTRPROPERTY_DEFAULTVALUEMUTABLE))) {
93  throw FormatException("Attribute '" + toString(attribute) + "' requires a either static or mutable default value");
94  }
95  // Attributes cannot be flowdefinition and enabilitablet at the same time
96  if ((attributeProperty & ATTRPROPERTY_FLOWDEFINITION) && (attributeProperty & ATTRPROPERTY_ACTIVATABLE)) {
97  throw FormatException("Attribute '" + toString(attribute) + "' cannot be flowdefinition and activatable at the same time");
98  }
99 }
100 
101 
103 
104 
105 void
107  // check that positive attributes correspond only to a int, floats or SUMOTimes
108  if (isPositive() && !(isInt() || isFloat() || isSUMOTime())) {
109  throw FormatException("Only int, floats or SUMOTimes can be positive");
110  }
111  // check that secuential attributes correspond to a list
112  if (isSecuential() && !isList()) {
113  throw FormatException("Secuential property only is compatible with list properties");
114  }
115  // check that synonym attribute isn't nothing
116  if (hasAttrSynonym() && (myAttrSynonym == SUMO_ATTR_NOTHING)) {
117  throw FormatException("synonym attribute cannot be nothing");
118  }
119  // check that ranges are valid
120  if (hasAttrRange()) {
121  if (myMinimumRange == myMaximumRange) {
122  throw FormatException("empty range");
123  } else if ((myMinimumRange == 0) && (myMaximumRange == 0)) {
124  throw FormatException("non-defined range");
125  } else if ((myMaximumRange - myMinimumRange) <= 0) {
126  throw FormatException("invalid range");
127  }
128  }
129  // check that positive attributes correspond only to a int, floats or SUMOTimes
130  if (isOptional() && !(hasStaticDefaultValue() || hasMutableDefaultValue())) {
131  throw FormatException("if attribute is optional, must have either a static or dynamic default value");
132  }
133 }
134 
135 
136 void
137 GNEAttributeCarrier::AttributeProperties::setDiscreteValues(const std::vector<std::string>& discreteValues) {
138  if (isDiscrete()) {
139  myDiscreteValues = discreteValues;
140  } else {
141  throw FormatException("AttributeProperty doesn't support discrete values values");
142  }
143 }
144 
145 
146 void
148  if (hasAttrSynonym()) {
149  myAttrSynonym = synonym;
150  } else {
151  throw FormatException("AttributeProperty doesn't support synonyms");
152  }
153 }
154 
155 
156 void
157 GNEAttributeCarrier::AttributeProperties::setRange(const double minimum, const double maximum) {
158  if (hasAttrRange()) {
159  myMinimumRange = minimum;
160  myMaximumRange = maximum;
161  // check that given range is valid
162  if (myMinimumRange == myMaximumRange) {
163  throw FormatException("empty range");
164  } else if ((myMinimumRange == 0) && (myMaximumRange == 0)) {
165  throw FormatException("non-defined range");
166  } else if ((myMaximumRange - myMinimumRange) <= 0) {
167  throw FormatException("invalid range");
168  }
169  } else {
170  throw FormatException("AttributeProperty doesn't support ranges");
171  }
172 }
173 
174 
175 void
177  myTagPropertyParent = tagPropertyParent;
178 }
179 
180 
183  return myAttribute;
184 }
185 
186 
187 const std::string&
189  return myAttrStr;
190 }
191 
192 
195  return *myTagPropertyParent;
196 }
197 
198 
199 int
201  for (auto i = myTagPropertyParent->begin(); i != myTagPropertyParent->end(); i++) {
202  if (i->getAttr() == myAttribute) {
203  return (int)(i - myTagPropertyParent->begin());
204  }
205  }
206  throw ProcessError("Attribute wasn't found in myTagPropertyParent");
207 }
208 
209 
210 const std::string&
212  return myDefinition;
213 }
214 
215 
216 const std::string&
218  return myDefaultValue;
219 }
220 
221 
222 std::string
224  std::string pre;
225  std::string type;
226  std::string plural;
227  std::string last;
228  // pre type
229  if ((myAttributeProperty & ATTRPROPERTY_LIST) != 0) {
230  pre += "list of ";
231  if ((myAttributeProperty & ATTRPROPERTY_VCLASS) != 0) {
232  plural = "es";
233  } else {
234  plural = "s";
235  }
236  }
237  if ((myAttributeProperty & ATTRPROPERTY_POSITIVE) != 0) {
238  pre += "positive ";
239  }
240  if ((myAttributeProperty & ATTRPROPERTY_DISCRETE) != 0) {
241  pre += "discrete ";
242  }
243  if ((myAttributeProperty & ATTRPROPERTY_OPTIONAL) != 0) {
244  pre += "optional ";
245  }
246  if ((myAttributeProperty & ATTRPROPERTY_UNIQUE) != 0) {
247  pre += "unique ";
248  }
249  if ((myAttributeProperty & ATTRPROPERTY_VCLASSES) != 0) {
250  pre += "vclasses ";
251  }
252  // type
253  if ((myAttributeProperty & ATTRPROPERTY_INT) != 0) {
254  type = "integer";
255  }
256  if ((myAttributeProperty & ATTRPROPERTY_FLOAT) != 0) {
257  type = "float";
258  }
259  if ((myAttributeProperty & ATTRPROPERTY_SUMOTIME) != 0) {
260  type = "SUMOTime";
261  }
262  if ((myAttributeProperty & ATTRPROPERTY_BOOL) != 0) {
263  type = "boolean";
264  }
265  if ((myAttributeProperty & ATTRPROPERTY_STRING) != 0) {
266  type = "string";
267  }
268  if ((myAttributeProperty & ATTRPROPERTY_POSITION) != 0) {
269  type = "position";
270  }
271  if ((myAttributeProperty & ATTRPROPERTY_COLOR) != 0) {
272  type = "color";
273  }
274  if ((myAttributeProperty & ATTRPROPERTY_VCLASS) != 0) {
275  type = "VClass";
276  }
277  if ((myAttributeProperty & ATTRPROPERTY_FILENAME) != 0) {
278  type = "filename";
279  }
280  if ((myAttributeProperty & ATTRPROPERTY_PROBABILITY) != 0) {
281  type = "probability";
282  last = "[0, 1]";
283  }
284  if ((myAttributeProperty & ATTRPROPERTY_ANGLE) != 0) {
285  type = "angle";
286  last = "[0, 360]";
287  }
288  return pre + type + plural + last;
289 }
290 
291 
292 const std::vector<std::string>&
294  return myDiscreteValues;
295 }
296 
297 
300  if (hasAttrSynonym()) {
301  return myAttrSynonym;
302  } else {
303  throw ProcessError("Attr doesn't support synonym");
304  }
305 }
306 
307 
308 double
310  if (hasAttrRange()) {
311  return myMinimumRange;
312  } else {
313  throw ProcessError("Attr doesn't support range");
314  }
315 }
316 
317 
318 double
320  if (hasAttrRange()) {
321  return myMaximumRange;
322  } else {
323  throw ProcessError("Attr doesn't support range");
324  }
325 }
326 
327 
328 bool
330  return (myAttributeProperty & ATTRPROPERTY_DEFAULTVALUESTATIC) != 0;
331 }
332 
333 
334 bool
336  return (myAttributeProperty & ATTRPROPERTY_DEFAULTVALUEMUTABLE) != 0;
337 }
338 
339 
340 bool
342  return (myAttributeProperty & ATTRPROPERTY_SYNONYM) != 0;
343 }
344 
345 bool
347  return (myAttributeProperty & ATTRPROPERTY_RANGE) != 0;
348 }
349 
350 
351 bool
353  return (myAttributeProperty & ATTRPROPERTY_INT) != 0;
354 }
355 
356 
357 bool
359  return (myAttributeProperty & ATTRPROPERTY_FLOAT) != 0;
360 }
361 
362 
363 bool
365  return (myAttributeProperty & ATTRPROPERTY_SUMOTIME) != 0;
366 }
367 
368 
369 bool
371  return (myAttributeProperty & ATTRPROPERTY_BOOL) != 0;
372 }
373 
374 
375 bool
377  return (myAttributeProperty & ATTRPROPERTY_STRING) != 0;
378 }
379 
380 
381 bool
383  return (myAttributeProperty & ATTRPROPERTY_POSITION) != 0;
384 }
385 
386 
387 bool
389  return (myAttributeProperty & ATTRPROPERTY_PROBABILITY) != 0;
390 }
391 
392 
393 bool
395  return (myAttributeProperty & (ATTRPROPERTY_INT | ATTRPROPERTY_FLOAT | ATTRPROPERTY_SUMOTIME)) != 0;
396 }
397 
398 
399 bool
401  return (myAttributeProperty & ATTRPROPERTY_POSITIVE) != 0;
402 }
403 
404 
405 bool
407  return (myAttributeProperty & ATTRPROPERTY_COLOR) != 0;
408 }
409 
410 
411 bool
413  return (myAttributeProperty & ATTRPROPERTY_FILENAME) != 0;
414 }
415 
416 
417 bool
419  return (myAttributeProperty & ATTRPROPERTY_VCLASS) != 0;
420 }
421 
422 
423 bool
425  return ((myAttributeProperty & ATTRPROPERTY_LIST) != 0) && ((myAttributeProperty & ATTRPROPERTY_VCLASS) != 0);
426 }
427 
428 
429 bool
431  return (myAttributeProperty & ATTRPROPERTY_LIST) != 0;
432 }
433 
434 
435 bool
437  return (myAttributeProperty & ATTRPROPERTY_SECUENCIAL) != 0;
438 }
439 
440 
441 bool
443  return (myAttributeProperty & ATTRPROPERTY_UNIQUE) != 0;
444 }
445 
446 
447 bool
449  return (myAttributeProperty & ATTRPROPERTY_OPTIONAL) != 0;
450 }
451 
452 
453 bool
455  return (myAttributeProperty & ATTRPROPERTY_DISCRETE) != 0;
456 }
457 
458 
459 bool
461  return (myAttributeProperty & ATTRPROPERTY_VCLASSES) != 0;
462 }
463 
464 
465 bool
467  return (myAttributeProperty & ATTRPROPERTY_EXTENDED) != 0;
468 }
469 
470 
471 bool
473  return (myAttributeProperty & ATTRPROPERTY_UPDATEGEOMETRY) != 0;
474 }
475 
476 
477 bool
479  return (myAttributeProperty & ATTRPROPERTY_ACTIVATABLE) != 0;
480 }
481 
482 
483 bool
485  return (myAttributeProperty & ATTRPROPERTY_COMPLEX) != 0;
486 }
487 
488 
489 bool
491  return (myAttributeProperty & ATTRPROPERTY_FLOWDEFINITION) != 0;
492 }
493 
494 // ---------------------------------------------------------------------------
495 // GNEAttributeCarrier::TagProperties - methods
496 // ---------------------------------------------------------------------------
497 
499  myTag(SUMO_TAG_NOTHING),
500  myTagType(0),
501  myTagProperty(0),
502  myIcon(ICON_EMPTY),
503  myParentTag(SUMO_TAG_NOTHING),
504  myTagSynonym(SUMO_TAG_NOTHING) {
505 }
506 
507 
508 GNEAttributeCarrier::TagProperties::TagProperties(SumoXMLTag tag, int tagType, int tagProperty, GUIIcon icon, SumoXMLTag parentTag, SumoXMLTag tagSynonym) :
509  myTag(tag),
510  myTagStr(toString(tag)),
511  myTagType(tagType),
512  myTagProperty(tagProperty),
513  myIcon(icon),
514  myParentTag(parentTag),
515  myTagSynonym(tagSynonym) {
516 }
517 
518 
520 
521 
524  return myTag;
525 }
526 
527 
528 const std::string&
530  return myTagStr;
531 }
532 
533 
534 void
536  // check that element must ist at least netElement, Additional, or shape
537  if (!isNetElement() && !isAdditional() && !isShape() && !isTAZ() && !isDemandElement()) {
538  throw ProcessError("element must be at leas netElement, additional, TAZ, shape or demandElement");
539  }
540  // check that element only is netElement, Additional, or shape at the same time
541  if ((isNetElement() + isAdditional() + isShape() + isTAZ() + isDemandElement()) > 1) {
542  throw ProcessError("element can be only a netElement, additional, shape or demandElement at the same time");
543  }
544  // if element can mask the start and end position, check that bot attributes exist
545  if (canMaskStartEndPos() && (!hasAttribute(SUMO_ATTR_STARTPOS) || !hasAttribute(SUMO_ATTR_ENDPOS))) {
546  throw ProcessError("If attribute mask the start and end position, bot attribute has to be defined");
547  }
548  // check that synonym tag isn't nothing
549  if (hasTagSynonym() && (myTagSynonym == SUMO_TAG_NOTHING)) {
550  throw FormatException("Synonym tag cannot be nothing");
551  }
552  // check that synonym was defined
553  if (!hasTagSynonym() && (myTagSynonym != SUMO_TAG_NOTHING)) {
554  throw FormatException("Tag doesn't support synonyms");
555  }
556  // check integrity of all attributes
557  for (auto i : myAttributeProperties) {
558  i.checkAttributeIntegrity();
559  // check that if attribute is vehicle classes, own a combination of Allow/disallow attibute
560  if (i.isVClasses()) {
561  if ((i.getAttr() != SUMO_ATTR_ALLOW) && (i.getAttr() != SUMO_ATTR_DISALLOW)) {
562  throw ProcessError("Attributes aren't combinables");
563  } else if ((i.getAttr() == SUMO_ATTR_ALLOW) && !hasAttribute(SUMO_ATTR_DISALLOW)) {
564  throw ProcessError("allow need a disallow attribute in the same tag");
565  } else if ((i.getAttr() == SUMO_ATTR_DISALLOW) && !hasAttribute(SUMO_ATTR_ALLOW)) {
566  throw ProcessError("disallow need an allow attribute in the same tag");
567  }
568  }
569  }
570 }
571 
572 
573 const std::string&
575  // iterate over attribute properties
576  for (const auto& i : myAttributeProperties) {
577  if (i.getAttr() == attr) {
578  if (!i.hasStaticDefaultValue()) {
579  throw ProcessError("attribute '" + i.getAttrStr() + "' doesn't have a default value");
580  } else {
581  return i.getDefaultValue();
582  }
583  }
584  }
585  throw ProcessError("Attribute '" + toString(attr) + "' not defined");
586 }
587 
588 
589 void
591  if (isAttributeDeprecated(attributeProperty.getAttr())) {
592  throw ProcessError("Attribute '" + attributeProperty.getAttrStr() + "' is deprecated and cannot be inserted");
593  } else if ((myAttributeProperties.size() + 1) >= MAXNUMBEROFATTRIBUTES) {
594  throw ProcessError("Maximum number of attributes for tag " + attributeProperty.getAttrStr() + " exceeded");
595  } else {
596  // Check that attribute wasn't already inserted
597  for (auto i : myAttributeProperties) {
598  if (i.getAttr() == attributeProperty.getAttr()) {
599  throw ProcessError("Attribute '" + attributeProperty.getAttrStr() + "' already inserted");
600  }
601  }
602  // insert AttributeProperties in vector
603  myAttributeProperties.push_back(attributeProperty);
604  myAttributeProperties.back().setTagPropertyParent(this);
605  }
606 }
607 
608 
609 void
611  // Check that attribute wasn't already inserted
612  for (auto i : myAttributeProperties) {
613  if (i.getAttr() == attr) {
614  throw ProcessError("Attribute '" + toString(attr) + "' is deprecated but was inserted in list of attributes");
615  }
616  }
617  // add it into myDeprecatedAttributes
618  myDeprecatedAttributes.push_back(attr);
619 }
620 
621 
624  // iterate over attribute properties
625  for (const auto& i : myAttributeProperties) {
626  if ((i.getAttr() == attr) || (i.hasAttrSynonym() && (i.getAttrSynonym() == attr))) {
627  return i;
628  }
629  }
630  // throw error if these attribute doesn't exist
631  throw ProcessError("Attribute '" + toString(attr) + "' doesn't exist");
632 }
633 
634 
635 std::vector<GNEAttributeCarrier::AttributeProperties>::const_iterator
637  return myAttributeProperties.begin();
638 }
639 
640 
641 std::vector<GNEAttributeCarrier::AttributeProperties>::const_iterator
643  return myAttributeProperties.end();
644 }
645 
646 
647 int
649  return (int)myAttributeProperties.size();
650 }
651 
652 
653 GUIIcon
655  return myIcon;
656 }
657 
658 
661  if (hasParent()) {
662  return myParentTag;
663  } else {
664  throw ProcessError("Tag doesn't have parent");
665  }
666 }
667 
668 
671  if (hasTagSynonym()) {
672  return myTagSynonym;
673  } else {
674  throw ProcessError("Tag doesn't have synonym");
675  }
676 }
677 
678 
679 bool
681  // iterate over attribute properties
682  for (const auto& i : myAttributeProperties) {
683  if (i.getAttr() == attr) {
684  return true;
685  }
686  }
687  return false;
688 }
689 
690 
691 bool
693  return (myTagType & TAGTYPE_NETELEMENT) != 0;
694 }
695 
696 
697 bool
699  return (myTagType & TAGTYPE_ADDITIONAL) != 0;
700 }
701 
702 bool
704  return (myTagType & TAGTYPE_SHAPE) != 0;
705 }
706 
707 
708 bool
710  return (myTagType & TAGTYPE_TAZ) != 0;
711 }
712 
713 
714 bool
716  return (myTagType & TAGTYPE_DEMANDELEMENT) != 0;
717 }
718 
719 
720 bool
722  return (myTagType & TAGTYPE_STOPPINGPLACE) != 0;
723 }
724 
725 
726 bool
728  return (myTagType & TAGTYPE_DETECTOR) != 0;
729 }
730 
731 
732 bool
734  return (myTagType & TAGTYPE_VTYPE) != 0;
735 }
736 
737 
738 bool
740  return (myTagType & TAGTYPE_VEHICLE) != 0;
741 }
742 
743 bool
745  return (myTagType & TAGTYPE_ROUTE) != 0;
746 }
747 
748 
749 bool
751  return (myTagType & TAGTYPE_STOP) != 0;
752 }
753 
754 
755 bool
757  return (myTagType & TAGTYPE_PERSON) != 0;
758 }
759 
760 
761 bool
763  return (myTagType & TAGTYPE_PERSONPLAN) != 0;
764 }
765 
766 
767 bool
769  return (myTagType & TAGTYPE_PERSONTRIP) != 0;
770 }
771 
772 
773 bool
775  return (myTagType & TAGTYPE_WALK) != 0;
776 }
777 
778 
779 bool
781  return (myTagType & TAGTYPE_RIDE) != 0;
782 }
783 
784 
785 bool
787  return (myTagType & TAGTYPE_PERSONSTOP) != 0;
788 }
789 
790 
791 bool
793  return (myTagProperty & TAGPROPERTY_DRAWABLE) != 0;
794 }
795 
796 
797 bool
799  return (myTagProperty & TAGPROPERTY_SELECTABLE) != 0;
800 }
801 
802 
803 bool
806 }
807 
808 
809 bool
811  return (myTagProperty & TAGPROPERTY_BLOCKSHAPE) != 0;
812 }
813 
814 
815 bool
817  return (myTagProperty & TAGPROPERTY_CLOSESHAPE) != 0;
818 }
819 
820 
821 bool
823  return (myTagProperty & TAGPROPERTY_GEOPOSITION) != 0;
824 }
825 
826 
827 bool
829  return (myTagProperty & TAGPROPERTY_GEOSHAPE) != 0;
830 }
831 
832 
833 bool
835  return (myTagProperty & TAGPROPERTY_PARENT) != 0;
836 }
837 
838 
839 bool
841  return (myTagProperty & TAGPROPERTY_SYNONYM) != 0;
842 }
843 
844 
845 bool
847  return (myTagProperty & TAGPROPERTY_DIALOG) != 0;
848 }
849 
850 
851 bool
854 }
855 
856 
857 bool
859  // note: By default all Tags supports parameters, except Tags with "TAGPROPERTY_NOPARAMETERS"
860  return (myTagProperty & TAGPROPERTY_NOPARAMETERS) == 0;
861 }
862 
863 
864 bool
866  return (myTagProperty & TAGPROPERTY_RTREE) != 0;
867 }
868 
869 
870 bool
873 }
874 
875 
876 bool
878  return (myTagProperty & TAGPROPERTY_REPARENT) != 0;
879 }
880 
881 
882 bool
885 }
886 
887 
888 bool
891 }
892 
893 
894 bool
897 }
898 
899 
900 bool
903 }
904 
905 
906 bool
909 }
910 
911 
912 bool
914  return (std::find(myDeprecatedAttributes.begin(), myDeprecatedAttributes.end(), attr) != myDeprecatedAttributes.end());
915 }
916 
917 // ---------------------------------------------------------------------------
918 // GNEAttributeCarrier - methods
919 // ---------------------------------------------------------------------------
920 
923  mySelected(false) {
924 }
925 
926 
928 
929 
930 template<> int
931 GNEAttributeCarrier::parse(const std::string& string) {
932  return StringUtils::toInt(string);
933 }
934 
935 
936 template<> double
937 GNEAttributeCarrier::parse(const std::string& string) {
938  return StringUtils::toDouble(string);
939 }
940 
941 
942 template<> SUMOTime
943 GNEAttributeCarrier::parse(const std::string& string) {
944  SUMOTime time = string2time(string);
945  if (time < 0) {
946  throw TimeFormatException("SUMOTIME cannot be negative");
947  } else {
948  return time;
949  }
950 }
951 
952 
953 template<> bool
954 GNEAttributeCarrier::parse(const std::string& string) {
955  return StringUtils::toBool(string);
956 }
957 
958 
959 template<> std::string
960 GNEAttributeCarrier::parse(const std::string& string) {
961  return string;
962 }
963 
964 
965 template<> SUMOVehicleClass
966 GNEAttributeCarrier::parse(const std::string& string) {
967  if (string.size() == 0) {
968  throw EmptyData();
969  } else if (!SumoVehicleClassStrings.hasString(string)) {
970  return SVC_IGNORING;
971  } else {
972  return SumoVehicleClassStrings.get(string);
973  }
974 }
975 
976 
977 template<> RGBColor
978 GNEAttributeCarrier::parse(const std::string& string) {
979  return RGBColor::parseColor(string);
980 }
981 
982 
983 template<> Position
984 GNEAttributeCarrier::parse(const std::string& string) {
985  if (string.size() == 0) {
986  throw EmptyData();
987  } else {
988  bool ok = true;
989  PositionVector pos = GeomConvHelper::parseShapeReporting(string, "user-supplied position", 0, ok, false, false);
990  if (!ok || (pos.size() != 1)) {
991  throw NumberFormatException("(Position) " + string);
992  } else {
993  return pos[0];
994  }
995  }
996 }
997 
998 
999 template<> PositionVector
1000 GNEAttributeCarrier::parse(const std::string& string) {
1001  PositionVector posVector;
1002  // empty string are allowed (It means empty position vector)
1003  if (string.empty()) {
1004  return posVector;
1005  } else {
1006  bool ok = true;
1007  posVector = GeomConvHelper::parseShapeReporting(string, "user-supplied shape", 0, ok, false, true);
1008  if (!ok) {
1009  throw NumberFormatException("(Position List) " + string);
1010  } else {
1011  return posVector;
1012  }
1013  }
1014 }
1015 
1016 
1017 template<> SUMOVehicleShape
1018 GNEAttributeCarrier::parse(const std::string& string) {
1019  if ((string == "unknown") || (!SumoVehicleShapeStrings.hasString(string))) {
1020  return SVS_UNKNOWN;
1021  } else {
1022  return SumoVehicleShapeStrings.get(string);
1023  }
1024 }
1025 
1026 
1027 template<> std::vector<std::string>
1028 GNEAttributeCarrier::parse(const std::string& string) {
1029  return StringTokenizer(string).getVector();
1030 }
1031 
1032 
1033 template<> std::set<std::string>
1034 GNEAttributeCarrier::parse(const std::string& string) {
1035  std::vector<std::string> vectorString = StringTokenizer(string).getVector();
1036  std::set<std::string> solution;
1037  for (const auto& i : vectorString) {
1038  solution.insert(i);
1039  }
1040  return solution;
1041 }
1042 
1043 
1044 template<> std::vector<int>
1045 GNEAttributeCarrier::parse(const std::string& string) {
1046  std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
1047  std::vector<int> parsedIntValues;
1048  for (const auto& i : parsedValues) {
1049  parsedIntValues.push_back(parse<int>(i));
1050  }
1051  return parsedIntValues;
1052 }
1053 
1054 
1055 template<> std::vector<double>
1056 GNEAttributeCarrier::parse(const std::string& string) {
1057  std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
1058  std::vector<double> parsedDoubleValues;
1059  for (const auto& i : parsedValues) {
1060  parsedDoubleValues.push_back(parse<double>(i));
1061  }
1062  return parsedDoubleValues;
1063 }
1064 
1065 
1066 template<> std::vector<bool>
1067 GNEAttributeCarrier::parse(const std::string& string) {
1068  std::vector<std::string> parsedValues = parse<std::vector<std::string> >(string);
1069  std::vector<bool> parsedBoolValues;
1070  for (const auto& i : parsedValues) {
1071  parsedBoolValues.push_back(parse<bool>(i));
1072  }
1073  return parsedBoolValues;
1074 }
1075 
1076 
1077 template<> std::vector<GNEEdge*>
1078 GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
1079  // Declare string vector
1080  std::vector<std::string> edgeIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
1081  std::vector<GNEEdge*> parsedEdges;
1082  // Iterate over edges IDs, retrieve Edges and add it into parsedEdges
1083  for (const auto& i : edgeIds) {
1084  GNEEdge* retrievedEdge = net->retrieveEdge(i, false);
1085  if (retrievedEdge) {
1086  parsedEdges.push_back(net->retrieveEdge(i));
1087  } else {
1088  throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_EDGES) + ". " + toString(SUMO_TAG_EDGE) + " '" + i + "' doesn't exist");
1089  }
1090  }
1091  return parsedEdges;
1092 }
1093 
1094 
1095 template<> std::vector<GNELane*>
1096 GNEAttributeCarrier::parse(GNENet* net, const std::string& value) {
1097  // Declare string vector
1098  std::vector<std::string> laneIds = GNEAttributeCarrier::parse<std::vector<std::string> > (value);
1099  std::vector<GNELane*> parsedLanes;
1100  // Iterate over lanes IDs, retrieve Lanes and add it into parsedLanes
1101  for (const auto& i : laneIds) {
1102  GNELane* retrievedLane = net->retrieveLane(i, false);
1103  if (retrievedLane) {
1104  parsedLanes.push_back(net->retrieveLane(i));
1105  } else {
1106  throw FormatException("Error parsing parameter " + toString(SUMO_ATTR_LANES) + ". " + toString(SUMO_TAG_LANE) + " '" + i + "' doesn't exist");
1107  }
1108  }
1109  return parsedLanes;
1110 }
1111 
1112 
1113 template<> std::string
1114 GNEAttributeCarrier::parseIDs(const std::vector<GNEEdge*>& ACs) {
1115  // obtain ID's of edges and return their join
1116  std::vector<std::string> edgeIDs;
1117  for (const auto& i : ACs) {
1118  edgeIDs.push_back(i->getID());
1119  }
1120  return joinToString(edgeIDs, " ");
1121 }
1122 
1123 
1124 template<> std::string
1125 GNEAttributeCarrier::parseIDs(const std::vector<GNELane*>& ACs) {
1126  // obtain ID's of lanes and return their join
1127  std::vector<std::string> laneIDs;
1128  for (const auto& i : ACs) {
1129  laneIDs.push_back(i->getID());
1130  }
1131  return joinToString(laneIDs, " ");
1132 }
1133 
1134 
1135 bool
1136 GNEAttributeCarrier::lanesConsecutives(const std::vector<GNELane*>& lanes) {
1137  // we need at least two lanes
1138  if (lanes.size() > 1) {
1139  // now check that lanes are consecutives (not neccesary connected)
1140  int currentLane = 0;
1141  while (currentLane < ((int)lanes.size() - 1)) {
1142  int nextLane = -1;
1143  // iterate over outgoing edges of destiny juntion of edge's lane
1144  for (int i = 0; (i < (int)lanes.at(currentLane)->getParentEdge()->getGNEJunctionDestiny()->getGNEOutgoingEdges().size()) && (nextLane == -1); i++) {
1145  // iterate over lanes of outgoing edges of destiny juntion of edge's lane
1146  for (int j = 0; (j < (int)lanes.at(currentLane)->getParentEdge()->getGNEJunctionDestiny()->getGNEOutgoingEdges().at(i)->getLanes().size()) && (nextLane == -1); j++) {
1147  // check if lane correspond to the next lane of "lanes"
1148  if (lanes.at(currentLane)->getParentEdge()->getGNEJunctionDestiny()->getGNEOutgoingEdges().at(i)->getLanes().at(j) == lanes.at(currentLane + 1)) {
1149  nextLane = currentLane;
1150  }
1151  }
1152  }
1153  if (nextLane == -1) {
1154  return false;
1155  } else {
1156  currentLane++;
1157  }
1158  }
1159  return true;
1160  } else {
1161  return false;
1162  }
1163 }
1164 
1165 
1166 std::string
1168  switch (key) {
1169  // Crossings
1170  case SUMO_ATTR_TLLINKINDEX:
1172  return "No TLS";
1173  // connections
1174  case SUMO_ATTR_DIR: {
1175  // special case for connection directions
1176  std::string direction = getAttribute(key);
1177  if (direction == "s") {
1178  return "Straight (s)";
1179  } else if (direction == "t") {
1180  return "Turn (t))";
1181  } else if (direction == "l") {
1182  return "Left (l)";
1183  } else if (direction == "r") {
1184  return "Right (r)";
1185  } else if (direction == "L") {
1186  return "Partially left (L)";
1187  } else if (direction == "R") {
1188  return "Partially right (R)";
1189  } else if (direction == "invalid") {
1190  return "No direction (Invalid))";
1191  } else {
1192  return "undefined";
1193  }
1194  }
1195  case SUMO_ATTR_STATE: {
1196  // special case for connection states
1197  std::string state = getAttribute(key);
1198  if (state == "-") {
1199  return "Dead end (-)";
1200  } else if (state == "=") {
1201  return "equal (=)";
1202  } else if (state == "m") {
1203  return "Minor link (m)";
1204  } else if (state == "M") {
1205  return "Major link (M)";
1206  } else if (state == "O") {
1207  return "TLS controller off (O)";
1208  } else if (state == "o") {
1209  return "TLS yellow flashing (o)";
1210  } else if (state == "y") {
1211  return "TLS yellow minor link (y)";
1212  } else if (state == "Y") {
1213  return "TLS yellow major link (Y)";
1214  } else if (state == "r") {
1215  return "TLS red (r)";
1216  } else if (state == "g") {
1217  return "TLS green minor (g)";
1218  } else if (state == "G") {
1219  return "TLS green major (G)";
1220  } else {
1221  return "undefined";
1222  }
1223  }
1224  // flows
1225  case SUMO_ATTR_VEHSPERHOUR:
1226  case SUMO_ATTR_PERIOD:
1227  case SUMO_ATTR_PROB:
1228  case SUMO_ATTR_END:
1229  case SUMO_ATTR_NUMBER:
1233  return "not together with number and period or probability";
1234  } else {
1235  return "not together with end and period or probability";
1236  }
1237  } else if (isAttributeEnabled(SUMO_ATTR_PERIOD)) {
1239  return "not together with number and vehsPerHour or probability";
1240  } else {
1241  return "not together with end and vehsPerHour or probability";
1242  }
1243  } else if (isAttributeEnabled(SUMO_ATTR_PROB)) {
1245  return "not together with number and vehsPerHour or period";
1246  } else {
1247  return "not together with end and vehsPerHour or period";
1248  }
1250  return "not together with end and number";
1251  }
1252  }
1253  FALLTHROUGH;
1254  default:
1255  return getAttribute(key);
1256  }
1257 }
1258 
1259 
1260 std::string
1262  return getAttribute(key);
1263 }
1264 
1265 
1266 const std::string&
1268  return myTagProperty.getTagStr();
1269 }
1270 
1271 
1274  return myTagProperty;
1275 }
1276 
1277 
1278 FXIcon*
1280  // define on first access
1281  if (myTagProperties.size() == 0) {
1283  }
1285 }
1286 
1287 
1288 const std::string
1290  return getAttribute(SUMO_ATTR_ID);
1291 }
1292 
1293 // ===========================================================================
1294 // static methods
1295 // ===========================================================================
1296 
1299  if (tag == SUMO_TAG_NOTHING) {
1300  return dummyTagProperty;
1301  }
1302  // define on first access
1303  if (myTagProperties.size() == 0) {
1305  }
1306  // check that tag is defined
1307  if (myTagProperties.count(tag) == 0) {
1308  throw ProcessError("Attributes for tag '" + toString(tag) + "' not defined");
1309  } else {
1310  return myTagProperties.at(tag);
1311  }
1312 }
1313 
1314 
1315 std::vector<SumoXMLTag>
1317  std::vector<SumoXMLTag> allTags;
1318  // define on first access
1319  if (myTagProperties.size() == 0) {
1321  }
1322  // fill all tags
1323  for (const auto& i : myTagProperties) {
1324  if (!onlyDrawables || i.second.isDrawable()) {
1325  allTags.push_back(i.first);
1326  }
1327  }
1328  return allTags;
1329 }
1330 
1331 
1332 std::vector<SumoXMLTag>
1333 GNEAttributeCarrier::allowedTagsByCategory(int tagPropertyCategory, bool onlyDrawables) {
1334  std::vector<SumoXMLTag> allowedTags;
1335  // define on first access
1336  if (myTagProperties.size() == 0) {
1338  }
1339  if (tagPropertyCategory & TAGTYPE_NETELEMENT) {
1340  // fill netElements tags
1341  for (const auto& i : myTagProperties) {
1342  if (i.second.isNetElement() && (!onlyDrawables || i.second.isDrawable())) {
1343  allowedTags.push_back(i.first);
1344  }
1345  }
1346  }
1347  if (tagPropertyCategory & TAGTYPE_ADDITIONAL) {
1348  // fill additional tags
1349  for (const auto& i : myTagProperties) {
1350  if (i.second.isAdditional() && (!onlyDrawables || i.second.isDrawable())) {
1351  allowedTags.push_back(i.first);
1352  }
1353  }
1354  }
1355  if (tagPropertyCategory & TAGTYPE_SHAPE) {
1356  // fill shape tags
1357  for (const auto& i : myTagProperties) {
1358  if (i.second.isShape() && (!onlyDrawables || i.second.isDrawable())) {
1359  allowedTags.push_back(i.first);
1360  }
1361  }
1362  }
1363  if (tagPropertyCategory & TAGTYPE_TAZ) {
1364  // fill taz tags
1365  for (const auto& i : myTagProperties) {
1366  if (i.second.isTAZ() && (!onlyDrawables || i.second.isDrawable())) {
1367  allowedTags.push_back(i.first);
1368  }
1369  }
1370  }
1371  if (tagPropertyCategory & TAGTYPE_DEMANDELEMENT) {
1372  // fill demand tags
1373  for (const auto& i : myTagProperties) {
1374  if (i.second.isDemandElement() && (!onlyDrawables || i.second.isDrawable())) {
1375  allowedTags.push_back(i.first);
1376  }
1377  }
1378  }
1379  if (tagPropertyCategory & TAGTYPE_ROUTE) {
1380  // fill demand tags
1381  for (const auto& i : myTagProperties) {
1382  if (i.second.isRoute() && (!onlyDrawables || i.second.isDrawable())) {
1383  allowedTags.push_back(i.first);
1384  }
1385  }
1386  }
1387  if (tagPropertyCategory & TAGTYPE_VEHICLE) {
1388  // fill demand tags
1389  for (const auto& i : myTagProperties) {
1390  if (i.second.isVehicle() && (!onlyDrawables || i.second.isDrawable())) {
1391  allowedTags.push_back(i.first);
1392  }
1393  }
1394  }
1395  if (tagPropertyCategory & TAGTYPE_STOP) {
1396  // fill demand tags
1397  for (const auto& i : myTagProperties) {
1398  if (i.second.isStop() && (!onlyDrawables || i.second.isDrawable())) {
1399  allowedTags.push_back(i.first);
1400  }
1401  }
1402  }
1403  if (tagPropertyCategory & TAGTYPE_PERSON) {
1404  // fill demand tags
1405  for (const auto& i : myTagProperties) {
1406  if (i.second.isPerson() && (!onlyDrawables || i.second.isDrawable())) {
1407  allowedTags.push_back(i.first);
1408  }
1409  }
1410  }
1411  if (tagPropertyCategory & TAGTYPE_PERSONPLAN) {
1412  // fill demand tags
1413  for (const auto& i : myTagProperties) {
1414  if (i.second.isPersonPlan() && (!onlyDrawables || i.second.isDrawable())) {
1415  allowedTags.push_back(i.first);
1416  }
1417  }
1418  }
1419  if (tagPropertyCategory & TAGTYPE_PERSONTRIP) {
1420  // fill demand tags
1421  for (const auto& i : myTagProperties) {
1422  if (i.second.isPersonTrip() && (!onlyDrawables || i.second.isDrawable())) {
1423  allowedTags.push_back(i.first);
1424  }
1425  }
1426  }
1427  if (tagPropertyCategory & TAGTYPE_WALK) {
1428  // fill demand tags
1429  for (const auto& i : myTagProperties) {
1430  if (i.second.isWalk() && (!onlyDrawables || i.second.isDrawable())) {
1431  allowedTags.push_back(i.first);
1432  }
1433  }
1434  }
1435  if (tagPropertyCategory & TAGTYPE_RIDE) {
1436  // fill demand tags
1437  for (const auto& i : myTagProperties) {
1438  if (i.second.isRide() && (!onlyDrawables || i.second.isDrawable())) {
1439  allowedTags.push_back(i.first);
1440  }
1441  }
1442  }
1443  if (tagPropertyCategory & TAGTYPE_PERSONSTOP) {
1444  // fill demand tags
1445  for (const auto& i : myTagProperties) {
1446  if (i.second.isPersonStop() && (!onlyDrawables || i.second.isDrawable())) {
1447  allowedTags.push_back(i.first);
1448  }
1449  }
1450  }
1451  return allowedTags;
1452 }
1453 
1454 
1455 // ===========================================================================
1456 // private
1457 // ===========================================================================
1458 
1459 void
1461  // fill all groups of ACs
1462  fillNetElements();
1463  fillAdditionals();
1464  fillShapes();
1467  fillStopElements();
1470  // check integrity of all Tags (function checkTagIntegrity() throw an exception if there is an inconsistency)
1471  for (const auto& i : myTagProperties) {
1472  i.second.checkTagIntegrity();
1473  }
1474 }
1475 
1476 
1477 void
1479  // declare empty AttributeProperties
1480  AttributeProperties attrProperty;
1481  // obtain Node Types except NODETYPE_DEAD_END_DEPRECATED
1482  const OptionsCont& oc = OptionsCont::getOptions();
1483  std::vector<std::string> nodeTypes = SUMOXMLDefinitions::NodeTypes.getStrings();
1484  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(NODETYPE_DEAD_END_DEPRECATED)));
1485  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(NODETYPE_DEAD_END)));
1486  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(NODETYPE_NOJUNCTION)));
1487  nodeTypes.erase(std::find(nodeTypes.begin(), nodeTypes.end(), toString(NODETYPE_INTERNAL)));
1488  // fill netElement ACs
1489  SumoXMLTag currentTag = SUMO_TAG_EDGE;
1490  {
1491  // set values of tag
1493  // set values of attributes
1494  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1496  "The id of the edge");
1497  myTagProperties[currentTag].addAttribute(attrProperty);
1498 
1499  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
1501  "The name of a node within the nodes-file the edge shall start at");
1502  myTagProperties[currentTag].addAttribute(attrProperty);
1503 
1504  attrProperty = AttributeProperties(SUMO_ATTR_TO,
1506  "The name of a node within the nodes-file the edge shall end at");
1507  myTagProperties[currentTag].addAttribute(attrProperty);
1508 
1509  attrProperty = AttributeProperties(SUMO_ATTR_SPEED,
1511  "The maximum speed allowed on the edge in m/s",
1512  toString(oc.getFloat("default.speed")));
1513  myTagProperties[currentTag].addAttribute(attrProperty);
1514 
1515  attrProperty = AttributeProperties(SUMO_ATTR_PRIORITY,
1517  "The priority of the edge",
1518  toString(oc.getInt("default.priority")));
1519  myTagProperties[currentTag].addAttribute(attrProperty);
1520 
1521  attrProperty = AttributeProperties(SUMO_ATTR_NUMLANES,
1523  "The number of lanes of the edge",
1524  toString(oc.getInt("default.lanenumber")));
1525  myTagProperties[currentTag].addAttribute(attrProperty);
1526 
1527  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
1529  "The name of a type within the SUMO edge type file");
1530  myTagProperties[currentTag].addAttribute(attrProperty);
1531 
1532  attrProperty = AttributeProperties(SUMO_ATTR_ALLOW,
1534  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1535  "all");
1536  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1537  myTagProperties[currentTag].addAttribute(attrProperty);
1538 
1539  attrProperty = AttributeProperties(SUMO_ATTR_DISALLOW,
1541  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1542  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1543  myTagProperties[currentTag].addAttribute(attrProperty);
1544 
1545  attrProperty = AttributeProperties(SUMO_ATTR_SHAPE,
1547  "If the shape is given it should start and end with the positions of the from-node and to-node");
1548  myTagProperties[currentTag].addAttribute(attrProperty);
1549 
1550  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
1552  "The length of the edge in meter");
1553  myTagProperties[currentTag].addAttribute(attrProperty);
1554 
1557  "Lane width for all lanes of this edge in meters (used for visualization)",
1558  "right");
1560  myTagProperties[currentTag].addAttribute(attrProperty);
1561 
1562  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
1564  "street name (need not be unique, used for visualization)");
1565  myTagProperties[currentTag].addAttribute(attrProperty);
1566 
1567  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
1569  "Lane width for all lanes of this edge in meters (used for visualization)",
1570  "-1");
1571  myTagProperties[currentTag].addAttribute(attrProperty);
1572 
1575  "Move the stop line back from the intersection by the given amount",
1576  "0");
1577  myTagProperties[currentTag].addAttribute(attrProperty);
1578 
1580  ATTRPROPERTY_STRING | ATTRPROPERTY_POSITION | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_UPDATEGEOMETRY, // virtual attribute used to define an endPoint
1581  "Custom position in which shape start (by default position of junction from)");
1582  myTagProperties[currentTag].addAttribute(attrProperty);
1583 
1584  attrProperty = AttributeProperties(GNE_ATTR_SHAPE_END,
1585  ATTRPROPERTY_STRING | ATTRPROPERTY_POSITION | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_UPDATEGEOMETRY, // virtual attribute from to define an endPoint
1586  "Custom position in which shape end (by default position of junction from)");
1587  myTagProperties[currentTag].addAttribute(attrProperty);
1588 
1589  attrProperty = AttributeProperties(GNE_ATTR_BIDIR,
1590  ATTRPROPERTY_BOOL | ATTRPROPERTY_DEFAULTVALUESTATIC, // virtual attribute to check of this edge is part of a bidirectional railway (cannot be edited)
1591  "Show if edge is bidireccional",
1592  "0");
1593  myTagProperties[currentTag].addAttribute(attrProperty);
1594 
1595  attrProperty = AttributeProperties(SUMO_ATTR_DISTANCE,
1597  "0");
1598  myTagProperties[currentTag].addAttribute(attrProperty);
1599 
1600  }
1601  currentTag = SUMO_TAG_JUNCTION;
1602  {
1603  // set values of tag
1605  // set values of attributes
1606  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1608  "The id of the node");
1609  myTagProperties[currentTag].addAttribute(attrProperty);
1610 
1611  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
1612  ATTRPROPERTY_STRING | ATTRPROPERTY_UNIQUE | ATTRPROPERTY_POSITION | ATTRPROPERTY_UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
1613  "The x-y-z position of the node on the plane in meters");
1614  myTagProperties[currentTag].addAttribute(attrProperty);
1615 
1616  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
1618  "An optional type for the node");
1619  attrProperty.setDiscreteValues(nodeTypes);
1620  myTagProperties[currentTag].addAttribute(attrProperty);
1621 
1622  attrProperty = AttributeProperties(SUMO_ATTR_SHAPE,
1624  "A custom shape for that node");
1625  myTagProperties[currentTag].addAttribute(attrProperty);
1626 
1627  attrProperty = AttributeProperties(SUMO_ATTR_RADIUS,
1629  "Optional turning radius (for all corners) for that node in meters",
1630  "1.5");
1631  myTagProperties[currentTag].addAttribute(attrProperty);
1632 
1635  "Whether the junction-blocking-heuristic should be activated at this node",
1636  "1");
1637  myTagProperties[currentTag].addAttribute(attrProperty);
1638 
1641  "How to compute right of way rules at this node",
1643  attrProperty.setDiscreteValues(SUMOXMLDefinitions::RightOfWayValues.getStrings());
1644  myTagProperties[currentTag].addAttribute(attrProperty);
1645 
1646  attrProperty = AttributeProperties(SUMO_ATTR_FRINGE,
1648  "Whether this junction is at the fringe of the network",
1650  attrProperty.setDiscreteValues(SUMOXMLDefinitions::FringeTypeValues.getStrings());
1651  myTagProperties[currentTag].addAttribute(attrProperty);
1652 
1653  attrProperty = AttributeProperties(SUMO_ATTR_TLTYPE,
1655  "An optional type for the traffic light algorithm");
1657  myTagProperties[currentTag].addAttribute(attrProperty);
1658 
1659  attrProperty = AttributeProperties(SUMO_ATTR_TLID,
1661  "An optional id for the traffic light program");
1662  myTagProperties[currentTag].addAttribute(attrProperty);
1663  }
1664  currentTag = SUMO_TAG_LANE;
1665  {
1666  // set values of tag
1668  // set values of attributes
1669  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1671  "ID of lane (Automatic, non editable)");
1672  myTagProperties[currentTag].addAttribute(attrProperty);
1673 
1674  attrProperty = AttributeProperties(SUMO_ATTR_INDEX,
1676  "The enumeration index of the lane (0 is the rightmost lane, <NUMBER_LANES>-1 is the leftmost one)");
1677  myTagProperties[currentTag].addAttribute(attrProperty);
1678 
1679  attrProperty = AttributeProperties(SUMO_ATTR_SPEED,
1681  "Speed in meters per second",
1682  "13.89");
1683  myTagProperties[currentTag].addAttribute(attrProperty);
1684 
1685  attrProperty = AttributeProperties(SUMO_ATTR_ALLOW,
1687  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1688  "all");
1689  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1690  myTagProperties[currentTag].addAttribute(attrProperty);
1691 
1692  attrProperty = AttributeProperties(SUMO_ATTR_DISALLOW,
1694  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1695  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1696  myTagProperties[currentTag].addAttribute(attrProperty);
1697 
1698  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
1700  "Width in meters (used for visualization)",
1701  "-1");
1702  myTagProperties[currentTag].addAttribute(attrProperty);
1703 
1706  "Move the stop line back from the intersection by the given amount",
1707  "0");
1708  myTagProperties[currentTag].addAttribute(attrProperty);
1709 
1712  "Enable or disable lane as acceleration lane",
1713  "0");
1714  myTagProperties[currentTag].addAttribute(attrProperty);
1715 
1718  "If the shape is given it overrides the computation based on edge shape");
1719  myTagProperties[currentTag].addAttribute(attrProperty);
1720  }
1721  currentTag = SUMO_TAG_CROSSING;
1722  {
1723  // set values of tag
1725  // set values of attributes
1726  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1728  "The ID of Crossing");
1729  myTagProperties[currentTag].addAttribute(attrProperty);
1730 
1731  attrProperty = AttributeProperties(SUMO_ATTR_EDGES,
1733  "The (road) edges which are crossed");
1734  myTagProperties[currentTag].addAttribute(attrProperty);
1735 
1736  attrProperty = AttributeProperties(SUMO_ATTR_PRIORITY,
1738  "Whether the pedestrians have priority over the vehicles (automatically set to true at tls-controlled intersections)",
1739  "0");
1740  myTagProperties[currentTag].addAttribute(attrProperty);
1741 
1742  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
1744  "The width of the crossings",
1745  toString(OptionsCont::getOptions().getFloat("default.crossing-width")));
1746  myTagProperties[currentTag].addAttribute(attrProperty);
1747 
1750  "sets the tls-index for this crossing",
1751  "-1");
1752  myTagProperties[currentTag].addAttribute(attrProperty);
1753 
1756  "sets the opposite-direction tls-index for this crossing",
1757  "-1");
1758  myTagProperties[currentTag].addAttribute(attrProperty);
1759 
1762  "Overrids default shape of pedestrian crossing");
1763  myTagProperties[currentTag].addAttribute(attrProperty);
1764  }
1765  currentTag = SUMO_TAG_CONNECTION;
1766  {
1767  // set values of tag
1769  // set values of attributes
1770  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
1772  "The name of the edge the vehicles leave");
1773  myTagProperties[currentTag].addAttribute(attrProperty);
1774 
1775  attrProperty = AttributeProperties(SUMO_ATTR_TO,
1777  "The name of the edge the vehicles may reach when leaving 'from'");
1778  myTagProperties[currentTag].addAttribute(attrProperty);
1779 
1782  "the lane index of the incoming lane (numbers starting with 0)");
1783  myTagProperties[currentTag].addAttribute(attrProperty);
1784 
1785  attrProperty = AttributeProperties(SUMO_ATTR_TO_LANE,
1787  "the lane index of the outgoing lane (numbers starting with 0)");
1788  myTagProperties[currentTag].addAttribute(attrProperty);
1789 
1790  attrProperty = AttributeProperties(SUMO_ATTR_PASS,
1792  "if set, vehicles which pass this (lane-2-lane) connection) will not wait",
1793  "0");
1794  myTagProperties[currentTag].addAttribute(attrProperty);
1795 
1798  "if set to false, vehicles which pass this (lane-2-lane) connection) will not worry about blocking the intersection",
1799  "0");
1800  myTagProperties[currentTag].addAttribute(attrProperty);
1801 
1802  attrProperty = AttributeProperties(SUMO_ATTR_CONTPOS,
1804  "If set to a more than 0 value, an internal junction will be built at this position (in m) from the start of the internal lane for this connection",
1806  myTagProperties[currentTag].addAttribute(attrProperty);
1807 
1810  "If set to true, This connection will not be TLS-controlled despite its node being controlled",
1811  "0");
1812  myTagProperties[currentTag].addAttribute(attrProperty);
1813 
1816  "Vision distance between vehicles",
1818  myTagProperties[currentTag].addAttribute(attrProperty);
1819 
1822  "sets index of this connection within the controlling trafficlight",
1823  "-1");
1824  myTagProperties[currentTag].addAttribute(attrProperty);
1825 
1828  "sets index for the internal junction of this connection within the controlling trafficlight",
1829  "-1");
1830  myTagProperties[currentTag].addAttribute(attrProperty);
1831 
1832  attrProperty = AttributeProperties(SUMO_ATTR_ALLOW,
1834  "Explicitly allows the given vehicle classes (not given will be not allowed)",
1835  "all");
1836  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1837  myTagProperties[currentTag].addAttribute(attrProperty);
1838 
1839  attrProperty = AttributeProperties(SUMO_ATTR_DISALLOW,
1841  "Explicitly disallows the given vehicle classes (not given will be allowed)");
1842  attrProperty.setDiscreteValues(SumoVehicleClassStrings.getStrings());
1843  myTagProperties[currentTag].addAttribute(attrProperty);
1844 
1845  attrProperty = AttributeProperties(SUMO_ATTR_SPEED,
1847  "sets custom speed limit for the connection",
1849  myTagProperties[currentTag].addAttribute(attrProperty);
1850 
1853  "sets custom shape for the connection");
1854  myTagProperties[currentTag].addAttribute(attrProperty);
1855 
1856  attrProperty = AttributeProperties(SUMO_ATTR_DIR,
1858  "turning direction for this connection (computed)");
1859  myTagProperties[currentTag].addAttribute(attrProperty);
1860 
1861  attrProperty = AttributeProperties(SUMO_ATTR_STATE,
1863  "link state for this connection (computed)");
1864  myTagProperties[currentTag].addAttribute(attrProperty);
1865  }
1866 }
1867 
1868 
1869 void
1871  // declare empty AttributeProperties
1872  AttributeProperties attrProperty;
1873  // fill additional elements
1874  SumoXMLTag currentTag = SUMO_TAG_BUS_STOP;
1875  {
1876  // set values of tag
1878  // set values of attributes
1879  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1881  "The id of bus stop");
1882  myTagProperties[currentTag].addAttribute(attrProperty);
1883 
1884  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
1886  "The name of the lane the bus stop shall be located at");
1887  myTagProperties[currentTag].addAttribute(attrProperty);
1888 
1889  attrProperty = AttributeProperties(SUMO_ATTR_STARTPOS,
1891  "The begin position on the lane (the lower position on the lane) in meters");
1892 
1893  myTagProperties[currentTag].addAttribute(attrProperty);
1894  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
1896  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1897  myTagProperties[currentTag].addAttribute(attrProperty);
1898 
1899  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
1901  "Name of " + toString(currentTag));
1902  myTagProperties[currentTag].addAttribute(attrProperty);
1903 
1906  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1907  "0");
1908  myTagProperties[currentTag].addAttribute(attrProperty);
1909 
1910  attrProperty = AttributeProperties(SUMO_ATTR_LINES,
1912  "Meant to be the names of the bus lines that stop at this bus stop. This is only used for visualization purposes");
1913  myTagProperties[currentTag].addAttribute(attrProperty);
1914 
1917  "Meant to be the names of the bus lines that stop at this bus stop. This is only used for visualization purposes",
1918  "-1");
1919  myTagProperties[currentTag].addAttribute(attrProperty);
1920  }
1921  currentTag = SUMO_TAG_ACCESS;
1922  {
1923  // set values of tag
1925  // set values of attributes
1926  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
1928  "The name of the lane the stop access shall be located at");
1929  myTagProperties[currentTag].addAttribute(attrProperty);
1930 
1931  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
1933  "The position on the lane (the lower position on the lane) in meters",
1934  "0");
1935  myTagProperties[currentTag].addAttribute(attrProperty);
1936 
1937  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
1939  "The walking length of the access in meters");
1940  myTagProperties[currentTag].addAttribute(attrProperty);
1941 
1944  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1945  "0");
1946  myTagProperties[currentTag].addAttribute(attrProperty);
1947 
1948  }
1949  currentTag = SUMO_TAG_CONTAINER_STOP;
1950  {
1951  // set values of tag
1953  // set values of attributes
1954  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1956  "The id of container stop");
1957  myTagProperties[currentTag].addAttribute(attrProperty);
1958 
1959  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
1961  "The name of the lane the container stop shall be located at");
1962  myTagProperties[currentTag].addAttribute(attrProperty);
1963 
1964  attrProperty = AttributeProperties(SUMO_ATTR_STARTPOS,
1966  "The begin position on the lane (the lower position on the lane) in meters");
1967  myTagProperties[currentTag].addAttribute(attrProperty);
1968 
1969  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
1971  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
1972  myTagProperties[currentTag].addAttribute(attrProperty);
1973 
1974  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
1976  "Name of " + toString(currentTag));
1977  myTagProperties[currentTag].addAttribute(attrProperty);
1978 
1981  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
1982  "0");
1983  myTagProperties[currentTag].addAttribute(attrProperty);
1984 
1985  attrProperty = AttributeProperties(SUMO_ATTR_LINES,
1987  "meant to be the names of the bus lines that stop at this container stop. This is only used for visualization purposes");
1988  myTagProperties[currentTag].addAttribute(attrProperty);
1989  }
1990  currentTag = SUMO_TAG_CHARGING_STATION;
1991  {
1992  // set values of tag
1994  // set values of attributes
1995  attrProperty = AttributeProperties(SUMO_ATTR_ID,
1997  "The id of charging station");
1998  myTagProperties[currentTag].addAttribute(attrProperty);
1999 
2000  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2002  "Lane of the charging station location");
2003  myTagProperties[currentTag].addAttribute(attrProperty);
2004 
2005  attrProperty = AttributeProperties(SUMO_ATTR_STARTPOS,
2007  "Begin position in the specified lane");
2008  myTagProperties[currentTag].addAttribute(attrProperty);
2009 
2010  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
2012  "End position in the specified lane");
2013  myTagProperties[currentTag].addAttribute(attrProperty);
2014 
2015  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2017  "Name of " + toString(currentTag));
2018  myTagProperties[currentTag].addAttribute(attrProperty);
2019 
2022  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2023  "0");
2024  myTagProperties[currentTag].addAttribute(attrProperty);
2025 
2028  "Charging power in W",
2029  "22000.00");
2030  myTagProperties[currentTag].addAttribute(attrProperty);
2031 
2034  "Charging efficiency [0,1]",
2035  "0.95");
2036  attrProperty.setRange(0, 1);
2037  myTagProperties[currentTag].addAttribute(attrProperty);
2038 
2041  "Enable or disable charge in transit, i.e. vehicle must or must not to stop for charging",
2042  "0");
2043  myTagProperties[currentTag].addAttribute(attrProperty);
2044 
2047  "Time delay after the vehicles has reached / stopped on the charging station, before the energy transfer (charging) begins",
2048  "0.00");
2049  myTagProperties[currentTag].addAttribute(attrProperty);
2050  }
2051  currentTag = SUMO_TAG_PARKING_AREA;
2052  {
2053  // set values of tag
2055  // set values of attributes
2056  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2058  "The id of ParkingArea");
2059  myTagProperties[currentTag].addAttribute(attrProperty);
2060 
2061  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2063  "The name of the lane the Parking Area shall be located at");
2064  myTagProperties[currentTag].addAttribute(attrProperty);
2065 
2066  attrProperty = AttributeProperties(SUMO_ATTR_STARTPOS,
2068  "The begin position on the lane (the lower position on the lane) in meters");
2069  myTagProperties[currentTag].addAttribute(attrProperty);
2070 
2071  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
2073  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
2074  myTagProperties[currentTag].addAttribute(attrProperty);
2075 
2076  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2078  "Name of " + toString(currentTag));
2079  myTagProperties[currentTag].addAttribute(attrProperty);
2080 
2083  " The number of parking spaces for road-side parking",
2084  "0");
2085  myTagProperties[currentTag].addAttribute(attrProperty);
2086 
2087  attrProperty = AttributeProperties(SUMO_ATTR_ONROAD,
2089  "If set, vehicles will park on the road lane and thereby reducing capacity",
2090  "0");
2091  myTagProperties[currentTag].addAttribute(attrProperty);
2092 
2095  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2096  "0");
2097  myTagProperties[currentTag].addAttribute(attrProperty);
2098 
2099  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
2101  "The width of the road-side parking spaces",
2102  "3.20");
2103  myTagProperties[currentTag].addAttribute(attrProperty);
2104 
2105  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
2107  "The length of the road-side parking spaces. By default (endPos - startPos) / roadsideCapacity");
2108  myTagProperties[currentTag].addAttribute(attrProperty);
2109 
2110  attrProperty = AttributeProperties(SUMO_ATTR_ANGLE,
2112  "The angle of the road-side parking spaces relative to the lane angle, positive means clockwise",
2113  "0.00");
2114  myTagProperties[currentTag].addAttribute(attrProperty);
2115 
2116  }
2117  currentTag = SUMO_TAG_PARKING_SPACE;
2118  {
2119  // set values of tag
2121  // set values of attributes
2122  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2123  ATTRPROPERTY_STRING | ATTRPROPERTY_UNIQUE | ATTRPROPERTY_POSITION | ATTRPROPERTY_UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2124  "The x-y-z position of the parking vehicle on the plane");
2125  myTagProperties[currentTag].addAttribute(attrProperty);
2126 
2127  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
2129  "The width of the road-side parking spaces",
2130  "3.20");
2131  myTagProperties[currentTag].addAttribute(attrProperty);
2132 
2133  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
2135  "The length of the road-side parking spaces",
2136  "5.00");
2137  myTagProperties[currentTag].addAttribute(attrProperty);
2138 
2139  attrProperty = AttributeProperties(SUMO_ATTR_ANGLE,
2141  "The angle of the road-side parking spaces relative to the lane angle, positive means clockwise",
2142  "0.00");
2143  myTagProperties[currentTag].addAttribute(attrProperty);
2144 
2145  }
2146  currentTag = SUMO_TAG_E1DETECTOR;
2147  {
2148  // set values of tag
2150  // set values of attributes
2151  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2153  "The id of E1");
2154  myTagProperties[currentTag].addAttribute(attrProperty);
2155 
2156  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2158  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2159  myTagProperties[currentTag].addAttribute(attrProperty);
2160 
2161  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2163  "The position on the lane the detector shall be laid on in meters. The position must be a value between -1*lane's length and the lane's length");
2164  myTagProperties[currentTag].addAttribute(attrProperty);
2165 
2168  "The aggregation period the values the detector collects shall be summed up",
2169  "900.00");
2170  myTagProperties[currentTag].addAttribute(attrProperty);
2171 
2172  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2174  "Name of " + toString(currentTag));
2175  myTagProperties[currentTag].addAttribute(attrProperty);
2176 
2177  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2179  "The path to the output file");
2180  myTagProperties[currentTag].addAttribute(attrProperty);
2181 
2182  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
2184  "Space separated list of vehicle type ids to consider");
2185  myTagProperties[currentTag].addAttribute(attrProperty);
2186 
2189  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2190  "0");
2191  myTagProperties[currentTag].addAttribute(attrProperty);
2192  }
2193  currentTag = SUMO_TAG_E2DETECTOR;
2194  {
2195  // set values of tag
2197  // set "file" as deprecated attribute
2198  myTagProperties[currentTag].addDeprecatedAttribute(SUMO_ATTR_CONT);
2199  // set values of attributes
2200  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2202  "The id of E2");
2203  myTagProperties[currentTag].addAttribute(attrProperty);
2204 
2205  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2207  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2208  myTagProperties[currentTag].addAttribute(attrProperty);
2209 
2210  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2212  "The position on the lane the detector shall be laid on in meters");
2213  myTagProperties[currentTag].addAttribute(attrProperty);
2214 
2215  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
2217  "The length of the detector in meters",
2218  "10.00");
2219  myTagProperties[currentTag].addAttribute(attrProperty);
2220 
2223  "The aggregation period the values the detector collects shall be summed up",
2224  "900.00");
2225  myTagProperties[currentTag].addAttribute(attrProperty);
2226 
2227  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2229  "Name of " + toString(currentTag));
2230  myTagProperties[currentTag].addAttribute(attrProperty);
2231 
2232  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2234  "The path to the output file");
2235  myTagProperties[currentTag].addAttribute(attrProperty);
2236 
2237  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
2239  "Space separated list of vehicle type ids to consider");
2240  myTagProperties[currentTag].addAttribute(attrProperty);
2241 
2244  "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)",
2245  "1.00");
2246  myTagProperties[currentTag].addAttribute(attrProperty);
2247 
2250  "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2251  "1.39");
2252  myTagProperties[currentTag].addAttribute(attrProperty);
2253 
2256  "The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m",
2257  "10.00");
2258  myTagProperties[currentTag].addAttribute(attrProperty);
2259 
2262  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2263  "0");
2264  myTagProperties[currentTag].addAttribute(attrProperty);
2265  }
2266  currentTag = SUMO_TAG_E2DETECTOR_MULTILANE;
2267  {
2268  // set values of tag
2270  // set "file" as deprecated attribute
2271  myTagProperties[currentTag].addDeprecatedAttribute(SUMO_ATTR_CONT);
2272  // set values of attributes
2273  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2275  "The id of Multilane E2");
2276  myTagProperties[currentTag].addAttribute(attrProperty);
2277 
2278  attrProperty = AttributeProperties(SUMO_ATTR_LANES,
2280  "The list of secuencial lane ids in which the detector shall be laid on");
2281  myTagProperties[currentTag].addAttribute(attrProperty);
2282 
2283  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2285  "The position on the lane the detector shall be laid on in meters");
2286  myTagProperties[currentTag].addAttribute(attrProperty);
2287 
2288  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
2290  "The end position on the lane the detector shall be laid on in meters");
2291  myTagProperties[currentTag].addAttribute(attrProperty);
2292 
2295  "The aggregation period the values the detector collects shall be summed up",
2296  "900.00");
2297  myTagProperties[currentTag].addAttribute(attrProperty);
2298 
2299  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2301  "Name of " + toString(currentTag));
2302  myTagProperties[currentTag].addAttribute(attrProperty);
2303 
2304  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2306  "The path to the output file");
2307  myTagProperties[currentTag].addAttribute(attrProperty);
2308 
2309  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
2311  "Space separated list of vehicle type ids to consider");
2312  myTagProperties[currentTag].addAttribute(attrProperty);
2313 
2316  "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting)",
2317  "1.00");
2318  myTagProperties[currentTag].addAttribute(attrProperty);
2319 
2322  "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2323  "1.39");
2324  myTagProperties[currentTag].addAttribute(attrProperty);
2325 
2328  "The minimum distance to the next standing vehicle in order to make this vehicle count as a participant to the jam) in m",
2329  "10.00");
2330  myTagProperties[currentTag].addAttribute(attrProperty);
2331 
2334  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2335  "0");
2336  myTagProperties[currentTag].addAttribute(attrProperty);
2337 
2338  }
2339  currentTag = SUMO_TAG_E3DETECTOR;
2340  {
2341  // set values of tag
2343  // set values of attributes
2344  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2346  "The id of E3");
2347  myTagProperties[currentTag].addAttribute(attrProperty);
2348 
2349  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2351  "X-Y position of detector in editor (Only used in NETEDIT)",
2352  "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2353  myTagProperties[currentTag].addAttribute(attrProperty);
2354 
2357  "The aggregation period the values the detector collects shall be summed up",
2358  "900.00");
2359  myTagProperties[currentTag].addAttribute(attrProperty);
2360 
2361  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2363  "Name of " + toString(currentTag));
2364  myTagProperties[currentTag].addAttribute(attrProperty);
2365 
2366  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2368  "The path to the output file");
2369  myTagProperties[currentTag].addAttribute(attrProperty);
2370 
2371  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
2373  "Space separated list of vehicle type ids to consider");
2374  myTagProperties[currentTag].addAttribute(attrProperty);
2375 
2378  "The time-based threshold that describes how much time has to pass until a vehicle is recognized as halting) in s",
2379  "1.00");
2380  myTagProperties[currentTag].addAttribute(attrProperty);
2381 
2384  "The speed-based threshold that describes how slow a vehicle has to be to be recognized as halting) in m/s",
2385  "1.39");
2386  myTagProperties[currentTag].addAttribute(attrProperty);
2387  }
2388  currentTag = SUMO_TAG_DET_ENTRY;
2389  {
2390  // set values of tag
2392  // set values of attributes
2393  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2395  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2396  myTagProperties[currentTag].addAttribute(attrProperty);
2397 
2398  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2400  "The position on the lane the detector shall be laid on in meters");
2401  myTagProperties[currentTag].addAttribute(attrProperty);
2402 
2405  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2406  "0");
2407  myTagProperties[currentTag].addAttribute(attrProperty);
2408 
2409  }
2410  currentTag = SUMO_TAG_DET_EXIT;
2411  {
2412  // set values of tag
2414  // set values of attributes
2415  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2417  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2418  myTagProperties[currentTag].addAttribute(attrProperty);
2419 
2420  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2422  "The position on the lane the detector shall be laid on in meters");
2423  myTagProperties[currentTag].addAttribute(attrProperty);
2424 
2427  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2428  "0");
2429  myTagProperties[currentTag].addAttribute(attrProperty);
2430 
2431  }
2432  currentTag = SUMO_TAG_INSTANT_INDUCTION_LOOP;
2433  {
2434  // set values of tag
2436  // set values of attributes
2437  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2439  "The id of Instant Induction Loop (E1Instant)");
2440  myTagProperties[currentTag].addAttribute(attrProperty);
2441 
2442  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2444  "The id of the lane the detector shall be laid on. The lane must be a part of the network used");
2445  myTagProperties[currentTag].addAttribute(attrProperty);
2446 
2447  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2449  "The position on the lane the detector shall be laid on in meters. The position must be a value between -1*lane's length and the lane's length");
2450  myTagProperties[currentTag].addAttribute(attrProperty);
2451 
2452  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2454  "Name of " + toString(currentTag));
2455  myTagProperties[currentTag].addAttribute(attrProperty);
2456 
2457  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2459  "The path to the output file");
2460  myTagProperties[currentTag].addAttribute(attrProperty);
2461 
2462  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
2464  "Space separated list of vehicle type ids to consider");
2465  myTagProperties[currentTag].addAttribute(attrProperty);
2466 
2469  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
2470  "0");
2471  myTagProperties[currentTag].addAttribute(attrProperty);
2472 
2473  }
2474  currentTag = SUMO_TAG_VSS;
2475  {
2476  // set values of tag
2478  // set "file" as deprecated attribute
2479  myTagProperties[currentTag].addDeprecatedAttribute(SUMO_ATTR_FILE);
2480  // set values of attributes
2481  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2483  "The id of Variable Speed Signal");
2484  myTagProperties[currentTag].addAttribute(attrProperty);
2485 
2486  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2488  "X-Y position of detector in editor (Only used in NETEDIT)",
2489  "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2490  myTagProperties[currentTag].addAttribute(attrProperty);
2491 
2492  attrProperty = AttributeProperties(SUMO_ATTR_LANES,
2494  "list of lanes of Variable Speed Sign");
2495  myTagProperties[currentTag].addAttribute(attrProperty);
2496 
2497  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2499  "Name of " + toString(currentTag));
2500  myTagProperties[currentTag].addAttribute(attrProperty);
2501  }
2502  currentTag = SUMO_TAG_STEP;
2503  {
2504  // set values of tag
2506  // set values of attributes
2507  attrProperty = AttributeProperties(SUMO_ATTR_TIME,
2509  "Time");
2510  myTagProperties[currentTag].addAttribute(attrProperty);
2511 
2512  attrProperty = AttributeProperties(SUMO_ATTR_SPEED,
2514  "Speed",
2515  "13.89");
2516  myTagProperties[currentTag].addAttribute(attrProperty);
2517  }
2518  currentTag = SUMO_TAG_CALIBRATOR;
2519  {
2520  // set values of tag
2522  // set values of attributes
2523  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2525  "The id of Calibrator");
2526  myTagProperties[currentTag].addAttribute(attrProperty);
2527 
2528  attrProperty = AttributeProperties(SUMO_ATTR_EDGE,
2530  "The id of edge in the simulation network");
2531  myTagProperties[currentTag].addAttribute(attrProperty);
2532 
2533  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2535  "The position of the calibrator on the specified lane",
2536  "0");
2537  myTagProperties[currentTag].addAttribute(attrProperty);
2538 
2541  "The aggregation interval in which to calibrate the flows. Default is step-length",
2542  "1.00");
2543  myTagProperties[currentTag].addAttribute(attrProperty);
2544 
2545  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2547  "Name of " + toString(currentTag));
2548  myTagProperties[currentTag].addAttribute(attrProperty);
2549 
2552  "The id of the routeProbe element from which to determine the route distribution for generated vehicles");
2553  myTagProperties[currentTag].addAttribute(attrProperty);
2554 
2555  attrProperty = AttributeProperties(SUMO_ATTR_OUTPUT,
2557  "The output file for writing calibrator information or NULL");
2558  myTagProperties[currentTag].addAttribute(attrProperty);
2559  }
2560  currentTag = SUMO_TAG_LANECALIBRATOR;
2561  {
2562  // set values of tag
2564  // set values of attributes
2565  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2567  "The id of Calibrator");
2568  myTagProperties[currentTag].addAttribute(attrProperty);
2569 
2570  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2572  "The id of lane in the simulation network");
2573  myTagProperties[currentTag].addAttribute(attrProperty);
2574 
2575  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2577  "The position of the calibrator on the specified lane",
2578  "0");
2579  myTagProperties[currentTag].addAttribute(attrProperty);
2580 
2583  "The aggregation interval in which to calibrate the flows. Default is step-length",
2584  "100.00");
2585  myTagProperties[currentTag].addAttribute(attrProperty);
2586 
2587  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2589  "Name of " + toString(currentTag));
2590  myTagProperties[currentTag].addAttribute(attrProperty);
2591 
2594  "The id of the routeProbe element from which to determine the route distribution for generated vehicles");
2595  myTagProperties[currentTag].addAttribute(attrProperty);
2596 
2597  attrProperty = AttributeProperties(SUMO_ATTR_OUTPUT,
2599  "The output file for writing calibrator information or NULL");
2600  myTagProperties[currentTag].addAttribute(attrProperty);
2601  }
2602  currentTag = SUMO_TAG_FLOW_CALIBRATOR;
2603  {
2604  // set values of tag
2606  // set values of attributes
2607  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
2609  "The id of the vehicle type to use for this " + toString(currentTag),
2611  myTagProperties[currentTag].addAttribute(attrProperty);
2612 
2613  attrProperty = AttributeProperties(SUMO_ATTR_ROUTE,
2615  "The id of the route the vehicle shall drive along");
2616  myTagProperties[currentTag].addAttribute(attrProperty);
2617 
2618  // fill common vehicle attributes
2619  fillCommonVehicleAttributes(currentTag);
2620 
2621  attrProperty = AttributeProperties(SUMO_ATTR_BEGIN,
2623  "First " + toString(currentTag) + " departure time",
2624  "0.00");
2625  myTagProperties[currentTag].addAttribute(attrProperty);
2626 
2627  attrProperty = AttributeProperties(SUMO_ATTR_END,
2629  "End of departure interval",
2630  "3600.00");
2631  myTagProperties[currentTag].addAttribute(attrProperty);
2632 
2635  "Number of " + toString(currentTag) + "s per hour, equally spaced");
2636  myTagProperties[currentTag].addAttribute(attrProperty);
2637 
2638  attrProperty = AttributeProperties(SUMO_ATTR_SPEED,
2640  "Speed of " + toString(currentTag) + "s");
2641  myTagProperties[currentTag].addAttribute(attrProperty);
2642  }
2643  currentTag = SUMO_TAG_REROUTER;
2644  {
2645  // set values of tag
2647  // set values of attributes
2648  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2650  "The id of Rerouter");
2651  myTagProperties[currentTag].addAttribute(attrProperty);
2652 
2653  attrProperty = AttributeProperties(SUMO_ATTR_EDGES,
2655  "An edge id or a list of edge ids where vehicles shall be rerouted");
2656  myTagProperties[currentTag].addAttribute(attrProperty);
2657 
2658  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
2660  "X,Y position in editor (Only used in NETEDIT)",
2661  "0,0"); // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
2662  myTagProperties[currentTag].addAttribute(attrProperty);
2663 
2664  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2666  "Name of " + toString(currentTag));
2667  myTagProperties[currentTag].addAttribute(attrProperty);
2668 
2669  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2671  "The path to the definition file (alternatively, the intervals may defined as children of the rerouter)");
2672  myTagProperties[currentTag].addAttribute(attrProperty);
2673 
2674  attrProperty = AttributeProperties(SUMO_ATTR_PROB,
2676  "The probability for vehicle rerouting (0-1)",
2677  "1.00");
2678  myTagProperties[currentTag].addAttribute(attrProperty);
2679 
2682  "The waiting time threshold (in s) that must be reached to activate rerouting (default -1 which disables the threshold)",
2683  "0.00");
2684  myTagProperties[currentTag].addAttribute(attrProperty);
2685 
2686  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
2688  "The list of vehicle types that shall be affected by this rerouter (empty to affect all types)");
2689  myTagProperties[currentTag].addAttribute(attrProperty);
2690 
2691  attrProperty = AttributeProperties(SUMO_ATTR_OFF,
2693  "Whether the router should be inactive initially (and switched on in the gui)",
2694  "0");
2695  myTagProperties[currentTag].addAttribute(attrProperty);
2696  }
2697  currentTag = SUMO_TAG_INTERVAL;
2698  {
2699  // set values of tag
2701  // set values of attributes
2702  attrProperty = AttributeProperties(SUMO_ATTR_BEGIN,
2704  "Begin",
2705  "0");
2706  myTagProperties[currentTag].addAttribute(attrProperty);
2707 
2708  attrProperty = AttributeProperties(SUMO_ATTR_END,
2710  "End",
2711  "3600.00");
2712  myTagProperties[currentTag].addAttribute(attrProperty);
2713  }
2714  currentTag = SUMO_TAG_CLOSING_REROUTE;
2715  {
2716  // set values of tag
2718  // set values of attributes
2719  attrProperty = AttributeProperties(SUMO_ATTR_EDGE,
2721  "Edge ID");
2722  attrProperty.setSynonym(SUMO_ATTR_ID);
2723  myTagProperties[currentTag].addAttribute(attrProperty);
2724 
2725  attrProperty = AttributeProperties(SUMO_ATTR_ALLOW,
2727  "allowed vehicles");
2728  myTagProperties[currentTag].addAttribute(attrProperty);
2729 
2730  attrProperty = AttributeProperties(SUMO_ATTR_DISALLOW,
2732  "disallowed vehicles");
2733  myTagProperties[currentTag].addAttribute(attrProperty);
2734  }
2735  currentTag = SUMO_TAG_CLOSING_LANE_REROUTE;
2736  {
2737  // set values of tag
2739  // set values of attributes
2740  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
2742  "Lane ID");
2743  attrProperty.setSynonym(SUMO_ATTR_ID);
2744  myTagProperties[currentTag].addAttribute(attrProperty);
2745 
2746  attrProperty = AttributeProperties(SUMO_ATTR_ALLOW,
2748  "allowed vehicles");
2749  myTagProperties[currentTag].addAttribute(attrProperty);
2750 
2751  attrProperty = AttributeProperties(SUMO_ATTR_DISALLOW,
2753  "disallowed vehicles");
2754  myTagProperties[currentTag].addAttribute(attrProperty);
2755  }
2756  currentTag = SUMO_TAG_DEST_PROB_REROUTE;
2757  {
2758  // set values of tag
2760  // set values of attributes
2761  attrProperty = AttributeProperties(SUMO_ATTR_EDGE,
2763  "Edge ID");
2764  attrProperty.setSynonym(SUMO_ATTR_ID);
2765  myTagProperties[currentTag].addAttribute(attrProperty);
2766 
2767  attrProperty = AttributeProperties(SUMO_ATTR_PROB,
2769  "SUMO Probability",
2770  "1.00");
2771  myTagProperties[currentTag].addAttribute(attrProperty);
2772  }
2773  currentTag = SUMO_TAG_PARKING_ZONE_REROUTE;
2774  {
2775  // set values of tag
2777  // set values of attributes
2778  attrProperty = AttributeProperties(SUMO_ATTR_PARKING,
2780  "ParkingArea ID");
2781  attrProperty.setSynonym(SUMO_ATTR_ID);
2782  myTagProperties[currentTag].addAttribute(attrProperty);
2783 
2784  attrProperty = AttributeProperties(SUMO_ATTR_PROB,
2786  "SUMO Probability",
2787  "1.00");
2788  myTagProperties[currentTag].addAttribute(attrProperty);
2789 
2790  attrProperty = AttributeProperties(SUMO_ATTR_VISIBLE,
2792  "Enable or disable visibility for parking area reroutes",
2793  "1");
2794  myTagProperties[currentTag].addAttribute(attrProperty);
2795  }
2796  currentTag = SUMO_TAG_ROUTE_PROB_REROUTE;
2797  {
2798  // set values of tag
2800  // set values of attributes
2801  attrProperty = AttributeProperties(SUMO_ATTR_ROUTE,
2803  "Route");
2804  attrProperty.setSynonym(SUMO_ATTR_ID);
2805  myTagProperties[currentTag].addAttribute(attrProperty);
2806 
2807  attrProperty = AttributeProperties(SUMO_ATTR_PROB,
2809  "SUMO Probability",
2810  "1.00");
2811  myTagProperties[currentTag].addAttribute(attrProperty);
2812  }
2813  currentTag = SUMO_TAG_ROUTEPROBE;
2814  {
2815  // set values of tag
2817  // set values of attributes
2818  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2820  "The id of RouteProbe");
2821  myTagProperties[currentTag].addAttribute(attrProperty);
2822 
2823  attrProperty = AttributeProperties(SUMO_ATTR_EDGE,
2825  "The id of an edge in the simulation network");
2826  myTagProperties[currentTag].addAttribute(attrProperty);
2827 
2830  "The frequency in which to report the distribution",
2831  "3600");
2832  myTagProperties[currentTag].addAttribute(attrProperty);
2833 
2834  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2836  "Name of " + toString(currentTag));
2837  myTagProperties[currentTag].addAttribute(attrProperty);
2838 
2839  attrProperty = AttributeProperties(SUMO_ATTR_FILE,
2841  "The file for generated output");
2842  myTagProperties[currentTag].addAttribute(attrProperty);
2843 
2844  attrProperty = AttributeProperties(SUMO_ATTR_BEGIN,
2846  "The time at which to start generating output",
2847  "0");
2848  myTagProperties[currentTag].addAttribute(attrProperty);
2849  }
2850  currentTag = SUMO_TAG_VAPORIZER;
2851  {
2852  // set values of tag
2854  // set values of attributes
2855  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2857  "Edge in which vaporizer is placed");
2858  myTagProperties[currentTag].addAttribute(attrProperty);
2859 
2860  attrProperty = AttributeProperties(SUMO_ATTR_BEGIN,
2862  "Start Time",
2863  "0");
2864  myTagProperties[currentTag].addAttribute(attrProperty);
2865 
2866  attrProperty = AttributeProperties(SUMO_ATTR_END,
2868  "End Time",
2869  "3600.00");
2870  myTagProperties[currentTag].addAttribute(attrProperty);
2871 
2872  attrProperty = AttributeProperties(SUMO_ATTR_NAME,
2874  "Name of " + toString(currentTag));
2875  myTagProperties[currentTag].addAttribute(attrProperty);
2876  }
2877  currentTag = SUMO_TAG_TAZ;
2878  {
2879  // set values of tag
2881  // set values of attributes
2882  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2884  "The id of the TAZ");
2885  myTagProperties[currentTag].addAttribute(attrProperty);
2886 
2887  attrProperty = AttributeProperties(SUMO_ATTR_SHAPE,
2889  "The shape of the TAZ");
2890  myTagProperties[currentTag].addAttribute(attrProperty);
2891 
2892  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
2894  "The RGBA color with which the TAZ shall be displayed",
2895  "red");
2896  myTagProperties[currentTag].addAttribute(attrProperty);
2897  }
2898  currentTag = SUMO_TAG_TAZSOURCE;
2899  {
2900  // set values of tag
2902  // set values of attributes
2903  attrProperty = AttributeProperties(SUMO_ATTR_EDGE,
2905  "The id of edge in the simulation network");
2906  attrProperty.setSynonym(SUMO_ATTR_ID);
2907  myTagProperties[currentTag].addAttribute(attrProperty);
2908 
2909  attrProperty = AttributeProperties(SUMO_ATTR_WEIGHT,
2911  "Depart weight associated to this Edge",
2912  "1");
2913  myTagProperties[currentTag].addAttribute(attrProperty);
2914  }
2915  currentTag = SUMO_TAG_TAZSINK;
2916  {
2917  // set values of tag
2919  // set values of attributes
2920  attrProperty = AttributeProperties(SUMO_ATTR_EDGE,
2922  "The id of edge in the simulation network");
2923  attrProperty.setSynonym(SUMO_ATTR_ID);
2924  myTagProperties[currentTag].addAttribute(attrProperty);
2925 
2926  attrProperty = AttributeProperties(SUMO_ATTR_WEIGHT,
2928  "Arrival weight associated to this Edget",
2929  "1");
2930  myTagProperties[currentTag].addAttribute(attrProperty);
2931  }
2932 }
2933 
2934 
2935 void
2937  // declare empty AttributeProperties
2938  AttributeProperties attrProperty;
2939  // fill shape ACs
2940  SumoXMLTag currentTag = SUMO_TAG_POLY;
2941  {
2942  // set values of tag
2944  // set values of attributes
2945  attrProperty = AttributeProperties(SUMO_ATTR_ID,
2947  "The id of the polygon");
2948  myTagProperties[currentTag].addAttribute(attrProperty);
2949 
2950  attrProperty = AttributeProperties(SUMO_ATTR_SHAPE,
2952  "The shape of the polygon");
2953  myTagProperties[currentTag].addAttribute(attrProperty);
2954 
2955  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
2957  "The RGBA color with which the polygon shall be displayed",
2958  "red");
2959  myTagProperties[currentTag].addAttribute(attrProperty);
2960 
2961  attrProperty = AttributeProperties(SUMO_ATTR_FILL,
2963  "An information whether the polygon shall be filled",
2964  "0");
2965  myTagProperties[currentTag].addAttribute(attrProperty);
2966 
2969  "The default line width for drawing an unfilled polygon",
2970  "1");
2971  myTagProperties[currentTag].addAttribute(attrProperty);
2972 
2973  attrProperty = AttributeProperties(SUMO_ATTR_LAYER,
2975  "The layer in which the polygon lies",
2977  myTagProperties[currentTag].addAttribute(attrProperty);
2978 
2979  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
2981  "A typename for the polygon",
2983  myTagProperties[currentTag].addAttribute(attrProperty);
2984 
2985  attrProperty = AttributeProperties(SUMO_ATTR_IMGFILE,
2987  "A bitmap to use for rendering this polygon",
2989  myTagProperties[currentTag].addAttribute(attrProperty);
2990 
2993  "Enable or disable use image file as a relative path",
2995  myTagProperties[currentTag].addAttribute(attrProperty);
2996 
2997  attrProperty = AttributeProperties(SUMO_ATTR_ANGLE,
2999  "Angle of rendered image in degree",
3001  myTagProperties[currentTag].addAttribute(attrProperty);
3002  }
3003  currentTag = SUMO_TAG_POI;
3004  {
3005  // set values of tag
3007  // set values of attributes
3008  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3010  "The id of the " + toString(currentTag));
3011  myTagProperties[currentTag].addAttribute(attrProperty);
3012 
3013  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
3014  ATTRPROPERTY_STRING | ATTRPROPERTY_POSITION | ATTRPROPERTY_UNIQUE | ATTRPROPERTY_UPDATEGEOMETRY, // virtual attribute from the combination of the actually attributes SUMO_ATTR_X, SUMO_ATTR_Y
3015  "The position in view");
3016  myTagProperties[currentTag].addAttribute(attrProperty);
3017 
3018  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3020  "The color with which the " + toString(currentTag) + " shall be displayed",
3021  "red");
3022  myTagProperties[currentTag].addAttribute(attrProperty);
3023 
3024  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
3026  "A typename for the " + toString(currentTag),
3028  myTagProperties[currentTag].addAttribute(attrProperty);
3029 
3030  attrProperty = AttributeProperties(SUMO_ATTR_LAYER,
3032  "The layer of the " + toString(currentTag) + " for drawing and selecting",
3034  myTagProperties[currentTag].addAttribute(attrProperty);
3035 
3036  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
3038  "Width of rendered image in meters",
3040  myTagProperties[currentTag].addAttribute(attrProperty);
3041 
3042  attrProperty = AttributeProperties(SUMO_ATTR_HEIGHT,
3044  "Height of rendered image in meters",
3046  myTagProperties[currentTag].addAttribute(attrProperty);
3047 
3048  attrProperty = AttributeProperties(SUMO_ATTR_IMGFILE,
3050  "A bitmap to use for rendering this " + toString(currentTag),
3052  myTagProperties[currentTag].addAttribute(attrProperty);
3053 
3056  "Enable or disable use image file as a relative path",
3058  myTagProperties[currentTag].addAttribute(attrProperty);
3059 
3060  attrProperty = AttributeProperties(SUMO_ATTR_ANGLE,
3062  "Angle of rendered image in degree",
3064  myTagProperties[currentTag].addAttribute(attrProperty);
3065  }
3066  currentTag = SUMO_TAG_POILANE;
3067  {
3068  // set values of tag
3070  // set values of attributes
3071  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3073  "The id of the " + toString(currentTag));
3074  myTagProperties[currentTag].addAttribute(attrProperty);
3075 
3076  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
3078  "The name of the lane at which the " + toString(currentTag) + " is located at");
3079  myTagProperties[currentTag].addAttribute(attrProperty);
3080 
3081  attrProperty = AttributeProperties(SUMO_ATTR_POSITION,
3083  "The position on the named lane or in the net in meters at which the " + toString(currentTag) + " is located at");
3084  myTagProperties[currentTag].addAttribute(attrProperty);
3085 
3088  "The lateral offset on the named lane at which the " + toString(currentTag) + " is located at",
3089  "0.00");
3090  myTagProperties[currentTag].addAttribute(attrProperty);
3091 
3092  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3094  "The color with which the " + toString(currentTag) + " shall be displayed",
3095  "red");
3096  myTagProperties[currentTag].addAttribute(attrProperty);
3097 
3098  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
3100  "A typename for the " + toString(currentTag),
3102  myTagProperties[currentTag].addAttribute(attrProperty);
3103 
3104  attrProperty = AttributeProperties(SUMO_ATTR_LAYER,
3106  "The layer of the " + toString(currentTag) + " for drawing and selecting",
3108  myTagProperties[currentTag].addAttribute(attrProperty);
3109 
3110  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
3112  "Width of rendered image in meters",
3114  myTagProperties[currentTag].addAttribute(attrProperty);
3115 
3116  attrProperty = AttributeProperties(SUMO_ATTR_HEIGHT,
3118  "Height of rendered image in meters",
3120  myTagProperties[currentTag].addAttribute(attrProperty);
3121 
3122  attrProperty = AttributeProperties(SUMO_ATTR_IMGFILE,
3124  "A bitmap to use for rendering this " + toString(currentTag),
3126  myTagProperties[currentTag].addAttribute(attrProperty);
3127 
3130  "Enable or disable use image file as a relative path",
3132  myTagProperties[currentTag].addAttribute(attrProperty);
3133 
3134  attrProperty = AttributeProperties(SUMO_ATTR_ANGLE,
3136  "Angle of rendered image in degree",
3138  myTagProperties[currentTag].addAttribute(attrProperty);
3139  }
3140 }
3141 
3142 
3143 void
3145  // first VClass separate between vehicles and persons
3146  std::vector<std::string> vClassesVehicles, vClassesPersons;
3147  auto vClasses = SumoVehicleClassStrings.getStrings();
3148  for (const auto& i : vClasses) {
3149  if (i == SumoVehicleClassStrings.getString(SVC_PEDESTRIAN)) {
3150  vClassesPersons.push_back(i);
3151  } else {
3152  vClassesVehicles.push_back(i);
3153  }
3154  }
3155  // declare empty AttributeProperties
3156  AttributeProperties attrProperty;
3157 
3158  // fill demand elements
3159  SumoXMLTag currentTag = SUMO_TAG_ROUTE;
3160  {
3161  // set values of tag
3163 
3164  // set values of attributes
3165  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3167  "The id of Route");
3168  myTagProperties[currentTag].addAttribute(attrProperty);
3169 
3170  attrProperty = AttributeProperties(SUMO_ATTR_EDGES,
3172  "The edges the vehicle shall drive along, given as their ids, separated using spaces");
3173  myTagProperties[currentTag].addAttribute(attrProperty);
3174 
3175  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3177  "This route's color",
3178  "yellow");
3179  myTagProperties[currentTag].addAttribute(attrProperty);
3180  }
3181  currentTag = SUMO_TAG_EMBEDDEDROUTE;
3182  {
3183  // set values of tag
3185 
3186  // set values of attributes
3187  attrProperty = AttributeProperties(SUMO_ATTR_EDGES,
3189  "The edges the vehicle shall drive along, given as their ids, separated using spaces");
3190  myTagProperties[currentTag].addAttribute(attrProperty);
3191 
3192  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3194  "This route's color",
3195  "yellow");
3196  myTagProperties[currentTag].addAttribute(attrProperty);
3197  }
3198  currentTag = SUMO_TAG_VTYPE;
3199  {
3200  // set values of tag
3202 
3203  // set values of attributes
3204  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3206  "The id of VehicleType");
3207  myTagProperties[currentTag].addAttribute(attrProperty);
3208 
3209  attrProperty = AttributeProperties(SUMO_ATTR_VCLASS,
3211  "An abstract vehicle class",
3212  "passenger");
3213  attrProperty.setDiscreteValues(vClassesVehicles);
3214  myTagProperties[currentTag].addAttribute(attrProperty);
3215 
3216  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3218  "This vehicle type's color",
3219  "");
3220  myTagProperties[currentTag].addAttribute(attrProperty);
3221 
3222  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
3224  "The vehicle's netto-length (length) [m]");
3225  myTagProperties[currentTag].addAttribute(attrProperty);
3226 
3227  attrProperty = AttributeProperties(SUMO_ATTR_MINGAP,
3229  "Empty space after leader [m]");
3230  myTagProperties[currentTag].addAttribute(attrProperty);
3231 
3232  attrProperty = AttributeProperties(SUMO_ATTR_MAXSPEED,
3234  "The vehicle's maximum velocity [m/s]");
3235  myTagProperties[currentTag].addAttribute(attrProperty);
3236 
3239  "The vehicles expected multiplicator for lane speed limits");
3240  myTagProperties[currentTag].addAttribute(attrProperty);
3241 
3242  attrProperty = AttributeProperties(SUMO_ATTR_SPEEDDEV,
3244  "The deviation of the speedFactor");
3245  myTagProperties[currentTag].addAttribute(attrProperty);
3246 
3249  "An abstract emission class");
3251  myTagProperties[currentTag].addAttribute(attrProperty);
3252 
3253  attrProperty = AttributeProperties(SUMO_ATTR_GUISHAPE,
3255  "How this vehicle is rendered");
3256  attrProperty.setDiscreteValues(SumoVehicleShapeStrings.getStrings());
3257  myTagProperties[currentTag].addAttribute(attrProperty);
3258 
3259  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
3261  "The vehicle's width [m] (only used for drawing)",
3262  "1.8");
3263  myTagProperties[currentTag].addAttribute(attrProperty);
3264 
3265  attrProperty = AttributeProperties(SUMO_ATTR_HEIGHT,
3267  "The vehicle's height [m] (only used for drawing)",
3268  "1.5");
3269  myTagProperties[currentTag].addAttribute(attrProperty);
3270 
3271  attrProperty = AttributeProperties(SUMO_ATTR_IMGFILE,
3273  "Image file for rendering vehicles of this type (should be grayscale to allow functional coloring)");
3274  myTagProperties[currentTag].addAttribute(attrProperty);
3275 
3278  "The model used for changing lanes",
3279  "default");
3280  attrProperty.setDiscreteValues(SUMOXMLDefinitions::LaneChangeModels.getStrings());
3281  myTagProperties[currentTag].addAttribute(attrProperty);
3282 
3285  "The model used for car following",
3286  "Krauss");
3287  attrProperty.setDiscreteValues(SUMOXMLDefinitions::CarFollowModels.getStrings());
3288  myTagProperties[currentTag].addAttribute(attrProperty);
3289 
3292  "The number of persons (excluding an autonomous driver) the vehicle can transport");
3293  myTagProperties[currentTag].addAttribute(attrProperty);
3294 
3297  "The number of containers the vehicle can transport");
3298  myTagProperties[currentTag].addAttribute(attrProperty);
3299 
3302  "The time required by a person to board the vehicle",
3303  "0.50");
3304  myTagProperties[currentTag].addAttribute(attrProperty);
3305 
3308  "The time required to load a container onto the vehicle",
3309  "90.00");
3310  myTagProperties[currentTag].addAttribute(attrProperty);
3311 
3314  "The preferred lateral alignment when using the sublane-model",
3315  "center");
3316  attrProperty.setDiscreteValues(SUMOXMLDefinitions::LateralAlignments.getStrings());
3317  myTagProperties[currentTag].addAttribute(attrProperty);
3318 
3321  "The minimum lateral gap at a speed difference of 50km/h when using the sublane-model",
3322  "0.12");
3323  myTagProperties[currentTag].addAttribute(attrProperty);
3324 
3327  "The maximum lateral speed when using the sublane-model",
3328  "1.00");
3329  myTagProperties[currentTag].addAttribute(attrProperty);
3330 
3333  "The interval length for which vehicle performs its decision logic (acceleration and lane-changing)",
3334  toString(OptionsCont::getOptions().getFloat("default.action-step-length")));
3335  myTagProperties[currentTag].addAttribute(attrProperty);
3336 
3337  attrProperty = AttributeProperties(SUMO_ATTR_PROB,
3339  "The probability when being added to a distribution without an explicit probability",
3341  myTagProperties[currentTag].addAttribute(attrProperty);
3342 
3343  attrProperty = AttributeProperties(SUMO_ATTR_OSGFILE,
3345  "3D model file for this class",
3346  "");
3347  myTagProperties[currentTag].addAttribute(attrProperty);
3348 
3351  "Carriage lengths");
3352  myTagProperties[currentTag].addAttribute(attrProperty);
3353 
3356  "Locomotive lengths");
3357  myTagProperties[currentTag].addAttribute(attrProperty);
3358 
3361  "GAP between carriages",
3362  "1");
3363  myTagProperties[currentTag].addAttribute(attrProperty);
3364 
3365  // fill VType Car Following Model Values (implemented in a separated function to improve code legibility)
3366  fillCarFollowingModelAttributes(currentTag);
3367 
3368  // fill VType Junction Model Parameters (implemented in a separated function to improve code legibility)
3369  fillJunctionModelAttributes(currentTag);
3370 
3371  // fill VType Lane Change Model Parameters (implemented in a separated function to improve code legibility)
3372  fillLaneChangingModelAttributes(currentTag);
3373  }
3374  currentTag = SUMO_TAG_PTYPE;
3375  {
3376  // set values of tag
3378 
3379  // set values of attributes
3380  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3382  "The id of PersonType");
3383  myTagProperties[currentTag].addAttribute(attrProperty);
3384 
3385  attrProperty = AttributeProperties(SUMO_ATTR_VCLASS,
3387  "An abstract person class",
3388  "pedestrian");
3389  attrProperty.setDiscreteValues(vClassesPersons);
3390  myTagProperties[currentTag].addAttribute(attrProperty);
3391 
3392  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3394  "This person type's color",
3395  "");
3396  myTagProperties[currentTag].addAttribute(attrProperty);
3397 
3398  attrProperty = AttributeProperties(SUMO_ATTR_WIDTH,
3400  "The person's width [m] (only used for drawing)");
3401  myTagProperties[currentTag].addAttribute(attrProperty);
3402 
3403  attrProperty = AttributeProperties(SUMO_ATTR_LENGTH,
3405  "The person's netto-length (length) [m]");
3406  myTagProperties[currentTag].addAttribute(attrProperty);
3407 
3408  attrProperty = AttributeProperties(SUMO_ATTR_MINGAP,
3410  "Empty space after leader [m]");
3411  myTagProperties[currentTag].addAttribute(attrProperty);
3412 
3413  attrProperty = AttributeProperties(SUMO_ATTR_MAXSPEED,
3415  "The person's maximum velocity [m/s]");
3416  myTagProperties[currentTag].addAttribute(attrProperty);
3417 
3420  "This value causes persons to violate a red light if the duration of the red phase is lower than the given threshold.",
3421  "-1");
3422  myTagProperties[currentTag].addAttribute(attrProperty);
3423 
3424  attrProperty = AttributeProperties(SUMO_ATTR_IMGFILE,
3426  "Image file for rendering persons of this type (should be grayscale to allow functional coloring)");
3427  myTagProperties[currentTag].addAttribute(attrProperty);
3428  }
3429 }
3430 
3431 
3432 void
3434  // declare empty AttributeProperties
3435  AttributeProperties attrProperty;
3436  // fill vehicle ACs
3437  SumoXMLTag currentTag = SUMO_TAG_VEHICLE;
3438  {
3439  // set values of tag
3441  // set values of attributes
3442  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3444  "The name of the " + toString(currentTag));
3445  myTagProperties[currentTag].addAttribute(attrProperty);
3446 
3447  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
3449  "The id of the vehicle type to use for this " + toString(currentTag),
3451  myTagProperties[currentTag].addAttribute(attrProperty);
3452 
3453  attrProperty = AttributeProperties(SUMO_ATTR_ROUTE,
3455  "The id of the route the " + toString(currentTag) + " shall drive along");
3456  myTagProperties[currentTag].addAttribute(attrProperty);
3457 
3458  // add common attributes
3459  fillCommonVehicleAttributes(currentTag);
3460 
3461  attrProperty = AttributeProperties(SUMO_ATTR_DEPART,
3463  "The time step at which the " + toString(currentTag) + " shall enter the network",
3464  "0");
3465  myTagProperties[currentTag].addAttribute(attrProperty);
3466  }
3467  currentTag = SUMO_TAG_ROUTEFLOW;
3468  {
3469  // set values of tag
3471  // set values of attributes
3472  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3474  "The name of the " + toString(currentTag));
3475  myTagProperties[currentTag].addAttribute(attrProperty);
3476 
3477  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
3479  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3481  myTagProperties[currentTag].addAttribute(attrProperty);
3482 
3483  attrProperty = AttributeProperties(SUMO_ATTR_ROUTE,
3485  "The id of the route the " + toString(currentTag) + " shall drive along");
3486  myTagProperties[currentTag].addAttribute(attrProperty);
3487 
3488  // add common attributes
3489  fillCommonVehicleAttributes(currentTag);
3490 
3491  // add flow attributes
3492  fillCommonFlowAttributes(currentTag);
3493  }
3494  currentTag = SUMO_TAG_TRIP;
3495  {
3496  // set values of tag
3498  // set values of attributes
3499  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3501  "The name of " + toString(currentTag) + "s that will be generated using this trip definition");
3502  myTagProperties[currentTag].addAttribute(attrProperty);
3503 
3504  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
3506  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3508  myTagProperties[currentTag].addAttribute(attrProperty);
3509 
3510  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3512  "The name of the edge the " + toString(currentTag) + " starts at");
3513  myTagProperties[currentTag].addAttribute(attrProperty);
3514 
3515  attrProperty = AttributeProperties(SUMO_ATTR_TO,
3517  "The name of the edge the " + toString(currentTag) + " ends at");
3518  myTagProperties[currentTag].addAttribute(attrProperty);
3519 
3520  attrProperty = AttributeProperties(SUMO_ATTR_VIA,
3522  "List of intermediate edge ids which shall be part of the " + toString(currentTag));
3523  myTagProperties[currentTag].addAttribute(attrProperty);
3524 
3525  // add common attributes
3526  fillCommonVehicleAttributes(currentTag);
3527 
3528  attrProperty = AttributeProperties(SUMO_ATTR_DEPART,
3530  "The departure time of the (first) " + toString(currentTag) + " which is generated using this " + toString(currentTag) + " definition",
3531  "0");
3532  myTagProperties[currentTag].addAttribute(attrProperty);
3533  }
3534  currentTag = SUMO_TAG_FLOW;
3535  {
3536  // set values of tag
3538  // set values of attributes
3539  attrProperty = AttributeProperties(SUMO_ATTR_ID,
3541  "The name of the " + toString(currentTag));
3542  myTagProperties[currentTag].addAttribute(attrProperty);
3543 
3544  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
3546  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag),
3548  myTagProperties[currentTag].addAttribute(attrProperty);
3549 
3550  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3552  "The name of the edge the " + toString(currentTag) + " starts at");
3553  myTagProperties[currentTag].addAttribute(attrProperty);
3554 
3555  attrProperty = AttributeProperties(SUMO_ATTR_TO,
3557  "The name of the edge the " + toString(currentTag) + " ends at");
3558  myTagProperties[currentTag].addAttribute(attrProperty);
3559 
3560  attrProperty = AttributeProperties(SUMO_ATTR_VIA,
3562  "List of intermediate edge ids which shall be part of the " + toString(currentTag));
3563  myTagProperties[currentTag].addAttribute(attrProperty);
3564 
3565  // add common attributes
3566  fillCommonVehicleAttributes(currentTag);
3567 
3568  // add flow attributes
3569  fillCommonFlowAttributes(currentTag);
3570  }
3571  /* currently disabled. See #5259
3572  currentTag = SUMO_TAG_TRIP_TAZ;
3573  {
3574  // set values of tag
3575  myTagProperties[currentTag] = TagProperties(currentTag, TAGTYPE_DEMANDELEMENT | TAGTYPE_VEHICLE, TAGPROPERTY_DRAWABLE, ICON_TRIP);
3576  }
3577  */
3578 }
3579 
3580 
3581 void
3583  // declare empty AttributeProperties
3584  AttributeProperties attrProperty;
3585  // fill stops ACs
3586  SumoXMLTag currentTag = SUMO_TAG_STOP_LANE;
3587  {
3588  // set values of tag
3590  // set values of attributes
3591  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
3593  "The name of the lane the stop shall be located at");
3594  myTagProperties[currentTag].addAttribute(attrProperty);
3595 
3596  attrProperty = AttributeProperties(SUMO_ATTR_STARTPOS,
3598  "The begin position on the lane (the lower position on the lane) in meters",
3599  "0");
3600  myTagProperties[currentTag].addAttribute(attrProperty);
3601 
3602  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
3604  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m",
3605  "0");
3606  myTagProperties[currentTag].addAttribute(attrProperty);
3607 
3610  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
3611  "0");
3612  myTagProperties[currentTag].addAttribute(attrProperty);
3613 
3614  // fill common stop attributes
3615  fillCommonStopAttributes(currentTag);
3616  }
3617  currentTag = SUMO_TAG_STOP_BUSSTOP;
3618  {
3619  // set values of tag
3621  // set values of attributes
3622  attrProperty = AttributeProperties(SUMO_ATTR_BUS_STOP,
3624  "BusStop associated with this stop");
3625  myTagProperties[currentTag].addAttribute(attrProperty);
3626 
3627  // fill common stop attributes
3628  fillCommonStopAttributes(currentTag);
3629  }
3630  currentTag = SUMO_TAG_STOP_CONTAINERSTOP;
3631  {
3632  // set values of tag
3634  // set values of attributes
3637  "ContainerStop associated with this stop");
3638  myTagProperties[currentTag].addAttribute(attrProperty);
3639 
3640  // fill common stop attributes
3641  fillCommonStopAttributes(currentTag);
3642  }
3643  currentTag = SUMO_TAG_STOP_CHARGINGSTATION;
3644  {
3645  // set values of tag
3647  // set values of attributes
3650  "ChargingStation associated with this stop");
3651  myTagProperties[currentTag].addAttribute(attrProperty);
3652 
3653  // fill common stop attributes
3654  fillCommonStopAttributes(currentTag);
3655  }
3656  currentTag = SUMO_TAG_STOP_PARKINGAREA;
3657  {
3658  // set values of tag
3660  // set values of attributes
3663  "ParkingArea associated with this stop");
3664  myTagProperties[currentTag].addAttribute(attrProperty);
3665 
3666  // fill common stop attributes
3667  fillCommonStopAttributes(currentTag);
3668  }
3669 }
3670 
3671 
3672 void
3674  // declare empty AttributeProperties
3675  AttributeProperties attrProperty;
3676  // fill vehicle ACs
3677  SumoXMLTag currentTag = SUMO_TAG_PERSON;
3678  {
3679  // set values of tag
3681 
3682  // add flow attributes
3683  fillCommonPersonAttributes(currentTag);
3684 
3685  // set specific attribute depart (note: Persons doesn't support triggered and containerTriggered values)
3686  attrProperty = AttributeProperties(SUMO_ATTR_DEPART,
3688  "The time step at which the " + toString(currentTag) + " shall enter the network",
3689  "0");
3690  myTagProperties[currentTag].addAttribute(attrProperty);
3691 
3692  }
3693  currentTag = SUMO_TAG_PERSONFLOW;
3694  {
3695  // set values of tag
3697 
3698  // add flow attributes
3699  fillCommonPersonAttributes(currentTag);
3700 
3701  // add flow attributes
3702  fillCommonFlowAttributes(currentTag);
3703  }
3704  currentTag = SUMO_TAG_PERSONTRIP_FROMTO;
3705  {
3706  // set values of tag
3708  // set values of attributes
3709  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3711  "The name of the edge the " + toString(currentTag) + " starts at");
3712  myTagProperties[currentTag].addAttribute(attrProperty);
3713 
3714  attrProperty = AttributeProperties(SUMO_ATTR_TO,
3716  "The name of the edge the " + toString(currentTag) + " ends at");
3717  myTagProperties[currentTag].addAttribute(attrProperty);
3718 
3719  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
3721  "List of possible vehicle types to take");
3722  myTagProperties[currentTag].addAttribute(attrProperty);
3723 
3724  attrProperty = AttributeProperties(SUMO_ATTR_MODES,
3726  "List of possible traffic modes. Walking is always possible regardless of this value");
3727  myTagProperties[currentTag].addAttribute(attrProperty);
3728 
3731  "arrival position on the destination edge",
3732  "-1");
3733  myTagProperties[currentTag].addAttribute(attrProperty);
3734  }
3735  currentTag = SUMO_TAG_PERSONTRIP_BUSSTOP;
3736  {
3737  // set values of tag
3739  // set values of attributes
3740  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3742  "The name of the edge the " + toString(currentTag) + " starts at");
3743  myTagProperties[currentTag].addAttribute(attrProperty);
3744 
3745  attrProperty = AttributeProperties(SUMO_ATTR_BUS_STOP,
3747  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
3748  myTagProperties[currentTag].addAttribute(attrProperty);
3749 
3750  attrProperty = AttributeProperties(SUMO_ATTR_VTYPES,
3752  "List of possible vehicle types to take");
3753  myTagProperties[currentTag].addAttribute(attrProperty);
3754 
3755  attrProperty = AttributeProperties(SUMO_ATTR_MODES,
3757  "List of possible traffic modes. Walking is always possible regardless of this value");
3758  myTagProperties[currentTag].addAttribute(attrProperty);
3759  }
3760  currentTag = SUMO_TAG_RIDE_FROMTO;
3761  {
3762  // set values of tag
3764  // set values of attributes
3765  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3767  "The name of the edge the " + toString(currentTag) + " starts at");
3768  myTagProperties[currentTag].addAttribute(attrProperty);
3769 
3770  attrProperty = AttributeProperties(SUMO_ATTR_TO,
3772  "The name of the edge the " + toString(currentTag) + " ends at");
3773  myTagProperties[currentTag].addAttribute(attrProperty);
3774 
3775  attrProperty = AttributeProperties(SUMO_ATTR_LINES,
3777  "list of vehicle alternatives to take for the " + toString(currentTag),
3778  "ANY");
3779  myTagProperties[currentTag].addAttribute(attrProperty);
3780 
3783  "arrival position on the destination edge",
3784  "-1");
3785  myTagProperties[currentTag].addAttribute(attrProperty);
3786  }
3787  currentTag = SUMO_TAG_RIDE_BUSSTOP;
3788  {
3789  // set values of tag
3791  // set values of attributes
3792  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3794  "The name of the edge the " + toString(currentTag) + " starts at");
3795  myTagProperties[currentTag].addAttribute(attrProperty);
3796 
3797  attrProperty = AttributeProperties(SUMO_ATTR_BUS_STOP,
3799  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
3800  myTagProperties[currentTag].addAttribute(attrProperty);
3801 
3802  attrProperty = AttributeProperties(SUMO_ATTR_LINES,
3804  "list of vehicle alternatives to take for the ride",
3805  "ANY");
3806  myTagProperties[currentTag].addAttribute(attrProperty);
3807  }
3808  currentTag = SUMO_TAG_WALK_EDGES;
3809  {
3810  // set values of tag
3812  // set values of attributes
3813  attrProperty = AttributeProperties(SUMO_ATTR_EDGES,
3815  "id of the edges to walk");
3816  myTagProperties[currentTag].addAttribute(attrProperty);
3817 
3820  "Arrival position on the destination edge",
3821  "-1");
3822  myTagProperties[currentTag].addAttribute(attrProperty);
3823  }
3824 
3825  currentTag = SUMO_TAG_WALK_ROUTE;
3826  {
3827  // set values of tag
3829  // set values of attributes
3830  attrProperty = AttributeProperties(SUMO_ATTR_ROUTE,
3832  "The id of the route to walk");
3833  myTagProperties[currentTag].addAttribute(attrProperty);
3834 
3837  "Arrival position on the destination edge",
3838  "-1");
3839  myTagProperties[currentTag].addAttribute(attrProperty);
3840  }
3841  currentTag = SUMO_TAG_WALK_FROMTO;
3842  {
3843  // set values of tag
3845  // set values of attributes
3846  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3848  "Id of the start edge");
3849  myTagProperties[currentTag].addAttribute(attrProperty);
3850 
3851  attrProperty = AttributeProperties(SUMO_ATTR_TO,
3853  "Id of the destination edge");
3854  myTagProperties[currentTag].addAttribute(attrProperty);
3855 
3856  attrProperty = AttributeProperties(SUMO_ATTR_VIA,
3858  "Ids of the intermediate edges");
3859  myTagProperties[currentTag].addAttribute(attrProperty);
3860 
3861 
3864  "Arrival position on the destination edge",
3865  "-1");
3866  myTagProperties[currentTag].addAttribute(attrProperty);
3867  }
3868 
3869  currentTag = SUMO_TAG_WALK_BUSSTOP;
3870  {
3871  // set values of tag
3873  // set values of attributes
3874  attrProperty = AttributeProperties(SUMO_ATTR_FROM,
3876  "Id of the start edge");
3877  myTagProperties[currentTag].addAttribute(attrProperty);
3878 
3879  attrProperty = AttributeProperties(SUMO_ATTR_BUS_STOP,
3881  "Id of the destination " + toString(SUMO_TAG_BUS_STOP));
3882  myTagProperties[currentTag].addAttribute(attrProperty);
3883  }
3884 }
3885 
3886 
3887 void
3889  // declare empty AttributeProperties
3890  AttributeProperties attrProperty;
3891  // fill vehicle ACs
3892  SumoXMLTag currentTag = SUMO_TAG_PERSONSTOP_LANE;
3893  {
3894  // set values of tag
3896  // set values of attributes
3897  attrProperty = AttributeProperties(SUMO_ATTR_LANE,
3899  "The name of the lane the stop shall be located at");
3900  myTagProperties[currentTag].addAttribute(attrProperty);
3901 
3902  attrProperty = AttributeProperties(SUMO_ATTR_STARTPOS,
3904  "The begin position on the lane (the lower position on the lane) in meters");
3905  myTagProperties[currentTag].addAttribute(attrProperty);
3906 
3907  attrProperty = AttributeProperties(SUMO_ATTR_ENDPOS,
3909  "The end position on the lane (the higher position on the lane) in meters, must be larger than startPos by more than 0.1m");
3910  myTagProperties[currentTag].addAttribute(attrProperty);
3911 
3914  "If set, no error will be reported if element is placed behind the lane. Instead,it will be placed 0.1 meters from the lanes end or at position 0.1, if the position was negative and larger than the lanes length after multiplication with - 1",
3915  "0");
3916  myTagProperties[currentTag].addAttribute(attrProperty);
3917 
3918  // fill common stop attributes
3919  fillCommonStopAttributes(currentTag);
3920  }
3921  currentTag = SUMO_TAG_PERSONSTOP_BUSSTOP;
3922  {
3923  // set values of tag
3925  // set values of attributes
3926  attrProperty = AttributeProperties(SUMO_ATTR_BUS_STOP,
3928  "BusStop associated with this stop");
3929  myTagProperties[currentTag].addAttribute(attrProperty);
3930 
3931  // fill common stop attributes
3932  fillCommonStopAttributes(currentTag);
3933  }
3934 }
3935 
3936 
3937 void
3939  // declare empty AttributeProperties
3940  AttributeProperties attrProperty;
3941 
3942  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
3944  "This " + toString(currentTag) + "'s color",
3945  "yellow");
3946  myTagProperties[currentTag].addAttribute(attrProperty);
3947 
3950  "The lane on which the " + toString(currentTag) + " shall be inserted",
3951  "first");
3952  myTagProperties[currentTag].addAttribute(attrProperty);
3953 
3955  ATTRPROPERTY_COMPLEX | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_OPTIONAL | ATTRPROPERTY_UPDATEGEOMETRY /* ATTRPROPERTY_MULTIDISCRETE (Currently disabled) */,
3956  "The position at which the " + toString(currentTag) + " shall enter the net",
3957  "base");
3958  myTagProperties[currentTag].addAttribute(attrProperty);
3959 
3961  ATTRPROPERTY_COMPLEX | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_OPTIONAL /* ATTRPROPERTY_MULTIDISCRETE (Currently disabled) */,
3962  "The speed with which the " + toString(currentTag) + " shall enter the network",
3963  "0");
3964  myTagProperties[currentTag].addAttribute(attrProperty);
3965 
3967  ATTRPROPERTY_COMPLEX | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_OPTIONAL | ATTRPROPERTY_UPDATEGEOMETRY /* ATTRPROPERTY_MULTIDISCRETE (Currently disabled) */,
3968  "The lane at which the " + toString(currentTag) + " shall leave the network",
3969  "current");
3970  myTagProperties[currentTag].addAttribute(attrProperty);
3971 
3973  ATTRPROPERTY_COMPLEX | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_OPTIONAL | ATTRPROPERTY_UPDATEGEOMETRY /* ATTRPROPERTY_MULTIDISCRETE (Currently disabled) */,
3974  "The position at which the " + toString(currentTag) + " shall leave the network",
3975  "max");
3976  myTagProperties[currentTag].addAttribute(attrProperty);
3977 
3979  ATTRPROPERTY_COMPLEX | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_OPTIONAL /* ATTRPROPERTY_MULTIDISCRETE (Currently disabled) */,
3980  "The speed with which the " + toString(currentTag) + " shall leave the network",
3981  "current");
3982  myTagProperties[currentTag].addAttribute(attrProperty);
3983 
3984  attrProperty = AttributeProperties(SUMO_ATTR_LINE,
3986  "A string specifying the id of a public transport line which can be used when specifying person rides");
3987  myTagProperties[currentTag].addAttribute(attrProperty);
3988 
3991  "The number of occupied seats when the " + toString(currentTag) + " is inserted",
3992  "0");
3993  myTagProperties[currentTag].addAttribute(attrProperty);
3994 
3997  "The number of occupied container places when the " + toString(currentTag) + " is inserted",
3998  "0");
3999  myTagProperties[currentTag].addAttribute(attrProperty);
4000 
4003  "The lateral position on the departure lane at which the " + toString(currentTag) + " shall enter the net",
4004  "center");
4005  myTagProperties[currentTag].addAttribute(attrProperty);
4006 
4009  "The lateral position on the arrival lane at which the " + toString(currentTag) + " shall arrive",
4010  "center");
4011  myTagProperties[currentTag].addAttribute(attrProperty);
4012 }
4013 
4014 
4015 void
4017  // declare empty AttributeProperties
4018  AttributeProperties attrProperty;
4019 
4020  attrProperty = AttributeProperties(SUMO_ATTR_BEGIN,
4022  "First " + toString(currentTag) + " departure time",
4023  "0.00");
4024  myTagProperties[currentTag].addAttribute(attrProperty);
4025 
4026  attrProperty = AttributeProperties(SUMO_ATTR_END,
4028  "End of departure interval",
4029  "3600.00");
4030  myTagProperties[currentTag].addAttribute(attrProperty);
4031 
4032  attrProperty = AttributeProperties(SUMO_ATTR_NUMBER,
4034  "probability for emitting a " + toString(currentTag) + " each second (not together with vehsPerHour or period)",
4035  "1800");
4036  myTagProperties[currentTag].addAttribute(attrProperty);
4037 
4040  "Number of " + toString(currentTag) + "s per hour, equally spaced (not together with period or probability)",
4041  "1800");
4042  myTagProperties[currentTag].addAttribute(attrProperty);
4043 
4044  attrProperty = AttributeProperties(SUMO_ATTR_PERIOD,
4046  "Insert equally spaced " + toString(currentTag) + "s at that period (not together with vehsPerHour or probability)",
4047  "2");
4048  myTagProperties[currentTag].addAttribute(attrProperty);
4049 
4050  attrProperty = AttributeProperties(SUMO_ATTR_PROB,
4052  "probability for emitting a " + toString(currentTag) + " each second (not together with vehsPerHour or period)",
4053  "0.5");
4054  myTagProperties[currentTag].addAttribute(attrProperty);
4055 }
4056 
4057 
4058 void
4060  // declare empty AttributeProperties
4061  AttributeProperties attrProperty;
4062 
4063  attrProperty = AttributeProperties(SUMO_ATTR_ACCEL,
4065  "The acceleration ability of vehicles of this type [m/s^2]",
4066  "2.60");
4067  myTagProperties[currentTag].addAttribute(attrProperty);
4068 
4069  attrProperty = AttributeProperties(SUMO_ATTR_DECEL,
4071  "The deceleration ability of vehicles of this type [m/s^2]",
4072  "4.50");
4073  myTagProperties[currentTag].addAttribute(attrProperty);
4074 
4077  "The apparent deceleration of the vehicle as used by the standard model [m/s^2]",
4078  "4.50");
4079  myTagProperties[currentTag].addAttribute(attrProperty);
4080 
4083  "The maximal physically possible deceleration for the vehicle [m/s^2]",
4084  "4.50");
4085  myTagProperties[currentTag].addAttribute(attrProperty);
4086 
4087  attrProperty = AttributeProperties(SUMO_ATTR_SIGMA,
4089  "Car-following model parameter",
4090  "0.50");
4091  attrProperty.setRange(0, 1);
4092  myTagProperties[currentTag].addAttribute(attrProperty);
4093 
4094  attrProperty = AttributeProperties(SUMO_ATTR_TAU,
4096  "Car-following model parameter",
4097  "1.00");
4098  myTagProperties[currentTag].addAttribute(attrProperty);
4099 
4100  attrProperty = AttributeProperties(SUMO_ATTR_TMP1,
4102  "SKRAUSSX parameter 1",
4103  "");
4104  myTagProperties[currentTag].addAttribute(attrProperty);
4105 
4106  attrProperty = AttributeProperties(SUMO_ATTR_TMP2,
4108  "SKRAUSSX parameter 2",
4109  "");
4110  myTagProperties[currentTag].addAttribute(attrProperty);
4111 
4112  attrProperty = AttributeProperties(SUMO_ATTR_TMP3,
4114  "SKRAUSSX parameter 3",
4115  "");
4116  myTagProperties[currentTag].addAttribute(attrProperty);
4117 
4118  attrProperty = AttributeProperties(SUMO_ATTR_TMP4,
4120  "SKRAUSSX parameter 4",
4121  "");
4122  myTagProperties[currentTag].addAttribute(attrProperty);
4123 
4124  attrProperty = AttributeProperties(SUMO_ATTR_TMP5,
4126  "SKRAUSSX parameter 5",
4127  "");
4128  myTagProperties[currentTag].addAttribute(attrProperty);
4129 
4132  "Peter Wagner 2009 parameter",
4133  "");
4134  myTagProperties[currentTag].addAttribute(attrProperty);
4135 
4138  "Peter Wagner 2009 parameter",
4139  "");
4140  myTagProperties[currentTag].addAttribute(attrProperty);
4141 
4144  "IDMM parameter",
4145  "");
4146  myTagProperties[currentTag].addAttribute(attrProperty);
4147 
4150  "IDMM parameter",
4151  "");
4152  myTagProperties[currentTag].addAttribute(attrProperty);
4153 
4156  "Wiedemann parameter",
4157  "");
4158  myTagProperties[currentTag].addAttribute(attrProperty);
4159 
4162  "Wiedemann parameter",
4163  "");
4164  myTagProperties[currentTag].addAttribute(attrProperty);
4165 
4168  "MinGap factor parameter",
4169  "");
4170  myTagProperties[currentTag].addAttribute(attrProperty);
4171 
4172  attrProperty = AttributeProperties(SUMO_ATTR_K,
4174  "K parameter",
4175  "");
4176  myTagProperties[currentTag].addAttribute(attrProperty);
4177 
4178 
4181  "Kerner Phi parameter",
4182  "");
4183  myTagProperties[currentTag].addAttribute(attrProperty);
4184 
4187  "IDM Delta parameter",
4188  "");
4189  myTagProperties[currentTag].addAttribute(attrProperty);
4190 
4193  "IDM Stepping parameter",
4194  "");
4195  myTagProperties[currentTag].addAttribute(attrProperty);
4196 
4199  "Train Types",
4200  "NGT400");
4201  attrProperty.setDiscreteValues(SUMOXMLDefinitions::TrainTypes.getStrings());
4202  myTagProperties[currentTag].addAttribute(attrProperty);
4203 }
4204 
4205 
4206 void
4208  // declare empty AttributeProperties
4209  AttributeProperties attrProperty;
4212  "Minimum distance to pedestrians that are walking towards the conflict point with the ego vehicle.",
4213  "10");
4214  myTagProperties[currentTag].addAttribute(attrProperty);
4215 
4218  "The accumulated waiting time after which a vehicle will drive onto an intersection even though this might cause jamming.",
4219  "-1");
4220  myTagProperties[currentTag].addAttribute(attrProperty);
4221 
4224  "This value causes vehicles to violate a yellow light if the duration of the yellow phase is lower than the given threshold.",
4225  "-1");
4226  myTagProperties[currentTag].addAttribute(attrProperty);
4227 
4230  "This value causes vehicles to violate a red light if the duration of the red phase is lower than the given threshold.",
4231  "-1");
4232  myTagProperties[currentTag].addAttribute(attrProperty);
4233 
4236  "This value causes vehicles affected by jmDriveAfterRedTime to slow down when violating a red light.",
4237  "0.0");
4238  myTagProperties[currentTag].addAttribute(attrProperty);
4239 
4242  "This value causes vehicles to ignore foe vehicles that have right-of-way with the given probability.",
4243  "0.0");
4244  myTagProperties[currentTag].addAttribute(attrProperty);
4245 
4248  "This value is used in conjunction with jmIgnoreFoeProb. Only vehicles with a speed below or equal to the given value may be ignored.",
4249  "0.0");
4250  myTagProperties[currentTag].addAttribute(attrProperty);
4251 
4254  "This value configures driving imperfection (dawdling) while passing a minor link.",
4255  "0.0");
4256  myTagProperties[currentTag].addAttribute(attrProperty);
4257 
4260  "This value defines the minimum time gap when passing ahead of a prioritized vehicle. ",
4261  "1");
4262  myTagProperties[currentTag].addAttribute(attrProperty);
4263 
4266  "Willingess of drivers to impede vehicles with higher priority",
4267  "0.0");
4268  myTagProperties[currentTag].addAttribute(attrProperty);
4269 }
4270 
4271 
4272 void
4274  // declare empty AttributeProperties
4275  AttributeProperties attrProperty;
4276 
4279  "The eagerness for performing strategic lane changing. Higher values result in earlier lane-changing.",
4280  "1.0");
4281  myTagProperties[currentTag].addAttribute(attrProperty);
4282 
4285  "The willingness for performing cooperative lane changing. Lower values result in reduced cooperation.",
4286  "1.0");
4287  myTagProperties[currentTag].addAttribute(attrProperty);
4288 
4291  "The eagerness for performing lane changing to gain speed. Higher values result in more lane-changing.",
4292  "1.0");
4293  myTagProperties[currentTag].addAttribute(attrProperty);
4294 
4297  "The eagerness for following the obligation to keep right. Higher values result in earlier lane-changing.",
4298  "1.0");
4299  myTagProperties[currentTag].addAttribute(attrProperty);
4300 
4303  "The eagerness for using the configured lateral alignment within the lane. Higher values result in increased willingness to sacrifice speed for alignment.",
4304  "1.0");
4305  myTagProperties[currentTag].addAttribute(attrProperty);
4306 
4309  "The eagerness for overtaking through the opposite-direction lane. Higher values result in more lane-changing.",
4310  "1.0");
4311  myTagProperties[currentTag].addAttribute(attrProperty);
4312 
4315  "Willingness to encroach laterally on other drivers.",
4316  "0.00");
4317  myTagProperties[currentTag].addAttribute(attrProperty);
4318 
4321  "Minimum lateral gap when encroaching laterally on other drives (alternative way to define lcPushy)",
4322  "0.00");
4323  myTagProperties[currentTag].addAttribute(attrProperty);
4324 
4327  "Willingness to accept lower front and rear gaps on the target lane.",
4328  "1.0");
4329  myTagProperties[currentTag].addAttribute(attrProperty);
4330 
4333  "Dynamic factor for modifying lcAssertive and lcPushy.",
4334  "0.00");
4335  myTagProperties[currentTag].addAttribute(attrProperty);
4336 
4339  "Time to reach maximum impatience (of 1). Impatience grows whenever a lane-change manoeuvre is blocked.",
4340  "infinity");
4341  myTagProperties[currentTag].addAttribute(attrProperty);
4342 
4345  "Maximum lateral acceleration per second.",
4346  "1.0");
4347  myTagProperties[currentTag].addAttribute(attrProperty);
4348 
4351  "Factor for configuring the strategic lookahead distance when a change to the left is necessary (relative to right lookahead).",
4352  "2.0");
4353  myTagProperties[currentTag].addAttribute(attrProperty);
4354 
4357  "Factor for configuring the treshold asymmetry when changing to the left or to the right for speed gain.",
4358  "0.1");
4359  myTagProperties[currentTag].addAttribute(attrProperty);
4360 
4363  "Upper bound on lateral speed when standing.",
4364  "0.00");
4365  myTagProperties[currentTag].addAttribute(attrProperty);
4366 
4369  "Upper bound on lateral speed while moving computed as lcMaxSpeedLatStanding + lcMaxSpeedLatFactor * getSpeed()",
4370  "1.00");
4371  myTagProperties[currentTag].addAttribute(attrProperty);
4372 
4375  "Distance to an upcoming turn on the vehicles route, below which the alignment should be dynamically adapted to match the turn direction.",
4376  "0.00");
4377  myTagProperties[currentTag].addAttribute(attrProperty);
4378 
4381  "The probability for violating rules gainst overtaking on the right.",
4382  "0.00");
4383  myTagProperties[currentTag].addAttribute(attrProperty);
4384 
4385  /*
4386  attrProperty = AttributeProperties(SUMO_ATTR_LCA_EXPERIMENTAL1,
4387  ATTRPROPERTY_FLOAT | ATTRPROPERTY_POSITIVE | ATTRPROPERTY_DEFAULTVALUESTATIC | ATTRPROPERTY_OPTIONAL | ATTRPROPERTY_EXTENDED,
4388  "XXXXX",
4389  "0.00");
4390  myTagProperties[currentTag].addAttribute(attrProperty);
4391  */
4392 }
4393 
4394 
4395 void
4397  // declare empty AttributeProperties
4398  AttributeProperties attrProperty;
4399 
4400  attrProperty = AttributeProperties(SUMO_ATTR_ID,
4402  "The name of the " + toString(currentTag));
4403  myTagProperties[currentTag].addAttribute(attrProperty);
4404 
4405  attrProperty = AttributeProperties(SUMO_ATTR_TYPE,
4407  "The id of the " + toString(currentTag) + " type to use for this " + toString(currentTag) +
4409  myTagProperties[currentTag].addAttribute(attrProperty);
4410 
4411  attrProperty = AttributeProperties(SUMO_ATTR_COLOR,
4413  "This " + toString(currentTag) + "'s color",
4414  "yellow");
4415  myTagProperties[currentTag].addAttribute(attrProperty);
4416 
4419  "The position at which the " + toString(currentTag) + " shall enter the net",
4420  "base");
4421  myTagProperties[currentTag].addAttribute(attrProperty);
4422 }
4423 
4424 
4425 void
4427  // declare empty AttributeProperties
4428  AttributeProperties attrProperty;
4429 
4430  attrProperty = AttributeProperties(SUMO_ATTR_DURATION,
4432  "Minimum duration for stopping",
4433  "60");
4434  myTagProperties[currentTag].addAttribute(attrProperty);
4435 
4436  attrProperty = AttributeProperties(SUMO_ATTR_UNTIL,
4438  "The time step at which the route continues",
4439  "0");
4440  myTagProperties[currentTag].addAttribute(attrProperty);
4441 
4444  "If set to a non-negative time value, then the stop duration can be extended at most by the extension value in seconds",
4445  "0");
4446  myTagProperties[currentTag].addAttribute(attrProperty);
4447 
4448  attrProperty = AttributeProperties(SUMO_ATTR_INDEX,
4450  "Where to insert the stop in the vehicle's list of stops",
4451  "end");
4452  myTagProperties[currentTag].addAttribute(attrProperty);
4453 
4456  "Whether a person may end the stop",
4457  "0");
4458  myTagProperties[currentTag].addAttribute(attrProperty);
4459 
4460  attrProperty = AttributeProperties(SUMO_ATTR_EXPECTED,
4462  "List of persons that must board the vehicle before it may continue");
4463  myTagProperties[currentTag].addAttribute(attrProperty);
4464 
4467  "Whether a container may end the stop",
4468  "0");
4469  myTagProperties[currentTag].addAttribute(attrProperty);
4470 
4473  "List of containers that must be loaded onto the vehicle before it may continue");
4474  myTagProperties[currentTag].addAttribute(attrProperty);
4475 
4476  attrProperty = AttributeProperties(SUMO_ATTR_PARKING,
4478  "whether the vehicle stops on the road or beside ",
4479  "0");
4480  myTagProperties[currentTag].addAttribute(attrProperty);
4481 
4482  attrProperty = AttributeProperties(SUMO_ATTR_ACTTYPE,
4484  "Activity displayed for stopped person in GUI and output files ",
4485  "waiting");
4486  myTagProperties[currentTag].addAttribute(attrProperty);
4487 
4494 }
4495 
4496 
4497 bool
4499  const AttributeProperties& attrProperties, const SumoXMLAttr attribute,
4500  std::string& defaultValue, std::string& parsedAttribute, std::string& warningMessage) {
4501  // declare a string for details about error formats
4502  std::string errorFormat;
4503  // set extra check for ID Values
4504  if (attribute == SUMO_ATTR_ID) {
4505  if (parsedAttribute.empty()) {
4506  errorFormat = "ID cannot be empty; ";
4507  } else if (tagProperties.isDetector()) {
4508  // special case for detectors (because in this case empty spaces are allowed)
4509  if (SUMOXMLDefinitions::isValidDetectorID(parsedAttribute) == false) {
4510  errorFormat = "Detector ID contains invalid characters; ";
4511  }
4512  } else if (tagProperties.isDemandElement()) {
4513  // special case for detectors (because in this case empty spaces are allowed)
4514  if (SUMOXMLDefinitions::isValidVehicleID(parsedAttribute) == false) {
4515  errorFormat = "Demand Element ID contains invalid characters; ";
4516  }
4517  } else if (SUMOXMLDefinitions::isValidAdditionalID(parsedAttribute) == false) {
4518  errorFormat = "ID contains invalid characters; ";
4519  }
4520  }
4521  // Set extra checks for int values
4522  if (attrProperties.isInt()) {
4523  if (canParse<int>(parsedAttribute)) {
4524  // obtain int value
4525  int parsedIntAttribute = parse<int>(parsedAttribute);
4526  // check if attribute can be negative or zero
4527  if (attrProperties.isPositive() && (parsedIntAttribute < 0)) {
4528  errorFormat = "Cannot be negative; ";
4529  }
4530  } else if (canParse<double>(parsedAttribute)) {
4531  errorFormat = "Float cannot be reinterpreted as int; ";
4532  } else {
4533  errorFormat = "Cannot be parsed to int; ";
4534  }
4535  }
4536  // Set extra checks for float(double) values
4537  if (attrProperties.isFloat()) {
4538  if (canParse<double>(parsedAttribute)) {
4539  // obtain double value
4540  double parsedDoubleAttribute = parse<double>(parsedAttribute);
4541  //check if can be negative and Zero
4542  if (attrProperties.isPositive() && (parsedDoubleAttribute < 0)) {
4543  errorFormat = "Cannot be negative; ";
4544  }
4545  } else {
4546  errorFormat = "Cannot be parsed to float; ";
4547  }
4548  }
4549  // Set extra checks for bool values
4550  if (attrProperties.isBool()) {
4551  if (!canParse<bool>(parsedAttribute)) {
4552  errorFormat = "Cannot be parsed to boolean; ";
4553  }
4554  }
4555  // Set extra checks for position values
4556  if (attrProperties.isposition()) {
4557  // check if we're parsing a single position or an entire shape
4558  if (attrProperties.isList()) {
4559  // check if parsed attribute can be parsed to Position Vector
4560  if (!canParse<PositionVector>(parsedAttribute)) {
4561  errorFormat = "List of Positions aren't neither x,y nor x,y,z; ";
4562  }
4563  } else if (!canParse<Position>(parsedAttribute)) {
4564  errorFormat = "Position is neither x,y nor x,y,z; ";
4565  }
4566  }
4567  // set extra check for time(double) values
4568  if (attrProperties.isSUMOTime()) {
4569  if (!canParse<SUMOTime>(parsedAttribute)) {
4570  errorFormat = "Cannot be parsed to SUMOTime; ";
4571  }
4572  }
4573  // set extra check for probability values
4574  if (attrProperties.isProbability()) {
4575  if (canParse<double>(parsedAttribute)) {
4576  // parse to double and check if is between [0,1]
4577  double probability = parse<double>(parsedAttribute);
4578  if (probability < 0) {
4579  errorFormat = "Probability cannot be smaller than 0; ";
4580  } else if (probability > 1) {
4581  errorFormat = "Probability cannot be greather than 1; ";
4582  }
4583  } else {
4584  errorFormat = "Cannot be parsed to probability; ";
4585  }
4586  }
4587  // set extra check for range values
4588  if (attrProperties.hasAttrRange()) {
4589  if (canParse<double>(parsedAttribute)) {
4590  // parse to double and check if is in range
4591  double range = parse<double>(parsedAttribute);
4592  if (range < attrProperties.getMinimumRange()) {
4593  errorFormat = "Float cannot be smaller than " + toString(attrProperties.getMinimumRange()) + "; ";
4594  } else if (range > attrProperties.getMaximumRange()) {
4595  errorFormat = "Float cannot be greather than " + toString(attrProperties.getMaximumRange()) + "; ";
4596  }
4597  } else {
4598  errorFormat = "Cannot be parsed to float; ";
4599  }
4600  }
4601  // set extra check for discrete values
4602  if (attrProperties.isDiscrete()) {
4603  // search value in the list of discretes values of attribute properties
4604  auto finder = std::find(attrProperties.getDiscreteValues().begin(), attrProperties.getDiscreteValues().end(), parsedAttribute);
4605  // check if attribute is valid
4606  if (finder == attrProperties.getDiscreteValues().end()) {
4607  errorFormat = "value is not within the set of allowed values for attribute '" + toString(attribute) + "'";
4608  }
4609  }
4610  // set extra check for color values
4611  if (attrProperties.isColor() && !canParse<RGBColor>(parsedAttribute)) {
4612  errorFormat = "Invalid RGB format or named color; ";
4613  }
4614  // set extra check for filename values
4615  if (attrProperties.isFilename()) {
4616  if (SUMOXMLDefinitions::isValidFilename(parsedAttribute) == false) {
4617  errorFormat = "Filename contains invalid characters; ";
4618  } else if (parsedAttribute.empty() && !attrProperties.isOptional()) {
4619  errorFormat = "Filename cannot be empty; ";
4620  }
4621  }
4622  // set extra check for name values
4623  if ((attribute == SUMO_ATTR_NAME) && !SUMOXMLDefinitions::isValidAttribute(parsedAttribute)) {
4624  errorFormat = "name contains invalid characters; ";
4625  }
4626  // set extra check for SVCPermissions values
4627  if (attrProperties.isVClass()) {
4628  if (!canParseVehicleClasses(parsedAttribute)) {
4629  errorFormat = "List of VClasses isn't valid; ";
4630  parsedAttribute = defaultValue;
4631  }
4632  }
4633  // set extra check for RouteProbes
4634  if ((attribute == SUMO_ATTR_ROUTEPROBE) && !SUMOXMLDefinitions::isValidAdditionalID(parsedAttribute)) {
4635  errorFormat = "RouteProbe ID contains invalid characters; ";
4636  }
4637  // set extra check for list of edges
4638  if ((attribute == SUMO_ATTR_EDGES) && parsedAttribute.empty()) {
4639  errorFormat = "List of edges cannot be empty; ";
4640  }
4641  // set extra check for list of lanes
4642  if ((attribute == SUMO_ATTR_LANES) && parsedAttribute.empty()) {
4643  errorFormat = "List of lanes cannot be empty; ";
4644  }
4645  // set extra check for list of VTypes
4646  if ((attribute == SUMO_ATTR_VTYPES) && !parsedAttribute.empty() && !SUMOXMLDefinitions::isValidListOfTypeID(parsedAttribute)) {
4647  errorFormat = "List of vTypes contains invalid characters; ";
4648  }
4649  // set extra check for list of RouteProbe
4650  if ((attribute == SUMO_ATTR_ROUTEPROBE) && !parsedAttribute.empty() && !SUMOXMLDefinitions::isValidAdditionalID(parsedAttribute)) {
4651  errorFormat = "RouteProbe ID contains invalid characters; ";
4652  }
4653  // If attribute has an invalid format
4654  if (errorFormat.size() > 0) {
4655  // if attribute is optional and has a default value, obtain it as string. In other case, abort.
4656  if (attrProperties.isOptional()) {
4657  WRITE_DEBUG("Format of optional " + attrProperties.getDescription() + " attribute '" + toString(attribute) + "' of " +
4658  warningMessage + " is invalid; " + errorFormat + "Default value will be used.");
4659  // set default value defined in AttrProperties
4660  parsedAttribute = attrProperties.getDefaultValue();
4661  } else {
4662  WRITE_WARNING("Format of essential " + attrProperties.getDescription() + " attribute '" + toString(attribute) + "' of " +
4663  warningMessage + " is invalid; " + errorFormat + tagProperties.getTagStr() + " cannot be created");
4664  // set default value (To avoid errors in parse<T>(parsedAttribute))
4665  parsedAttribute = defaultValue;
4666  // return false to abort creation of element
4667  return false;
4668  }
4669  }
4670  // return true to continue creation of element
4671  return true;
4672 }
4673 
4674 
4675 bool
4676 GNEAttributeCarrier::parseMaskedPositionAttribute(const SUMOSAXAttributes& attrs, const std::string& objectID, const TagProperties& tagProperties,
4677  const AttributeProperties& attrProperties, std::string& parsedAttribute, std::string& warningMessage) {
4678  // if element can mask their XYPosition, then must be extracted X Y coordiantes separeted
4679  std::string x, y, z;
4680  bool parsedOk = true;
4681  // give a default value to parsedAttribute to avoid problem parsing invalid positions
4682  parsedAttribute = "0,0";
4683  if (attrs.hasAttribute(SUMO_ATTR_X)) {
4684  x = attrs.get<std::string>(SUMO_ATTR_X, objectID.c_str(), parsedOk, false);
4685  // check that X attribute is valid
4686  if (!canParse<double>(x)) {
4687  WRITE_WARNING("Format of essential " + attrProperties.getDescription() + " attribute '" + toString(SUMO_ATTR_X) + "' of " +
4688  warningMessage + " is invalid; Cannot be parsed to float; " + tagProperties.getTagStr() + " cannot be created");
4689  // abort parsing (and creation) of element
4690  return false;
4691  }
4692  } else {
4693  WRITE_WARNING("Essential " + attrProperties.getDescription() + " attribute '" + toString(SUMO_ATTR_X) + "' of " +
4694  warningMessage + " is missing; " + tagProperties.getTagStr() + " cannot be created");
4695  // abort parsing (and creation) of element
4696  return false;
4697  }
4698  if (attrs.hasAttribute(SUMO_ATTR_Y)) {
4699  y = attrs.get<std::string>(SUMO_ATTR_Y, objectID.c_str(), parsedOk, false);
4700  // check that X attribute is valid
4701  if (!canParse<double>(y)) {
4702  WRITE_WARNING("Format of essential " + attrProperties.getDescription() + " attribute '" + toString(SUMO_ATTR_Y) + "' of " +
4703  warningMessage + " is invalid; Cannot be parsed to float; " + tagProperties.getTagStr() + " cannot be created");
4704  // abort parsing (and creation) of element
4705  return false;
4706  }
4707  } else {
4708  WRITE_WARNING("Essential " + attrProperties.getDescription() + " attribute '" + toString(SUMO_ATTR_Y) + "' of " +
4709  warningMessage + " is missing; " + tagProperties.getTagStr() + " cannot be created");
4710  // abort parsing (and creation) of element
4711  return false;
4712  }
4713  // Z attribute is optional
4714  if (attrs.hasAttribute(SUMO_ATTR_Z)) {
4715  z = attrs.get<std::string>(SUMO_ATTR_Z, objectID.c_str(), parsedOk, false);
4716  // check that Z attribute is valid
4717  if (!canParse<double>(z)) {
4718  WRITE_WARNING("Format of optional " + attrProperties.getDescription() + " attribute '" + toString(SUMO_ATTR_Z) + "' of " +
4719  warningMessage + " is invalid; Cannot be parsed to float; " + tagProperties.getTagStr() + " cannot be created");
4720  // leave Z attribute empty
4721  z.clear();
4722  }
4723  }
4724  // create Position attribute using parsed coordinates X, Y and, optionally, Z
4725  if (z.empty()) {
4726  parsedAttribute = x + "," + y;
4727  } else {
4728  parsedAttribute = x + "," + y + "," + z;
4729  }
4730  // continue creation of element
4731  return true;
4732 }
4733 
4734 /****************************************************************************/
GNEAttributeCarrier::AttributeProperties::setSynonym
void setSynonym(const SumoXMLAttr synonym)
set synonim
Definition: GNEAttributeCarrier.cpp:147
SUMO_ATTR_ENDOFFSET
@ SUMO_ATTR_ENDOFFSET
Definition: SUMOXMLDefinitions.h:414
GNEAttributeCarrier::TAGPROPERTY_WRITECHILDRENSEPARATE
@ TAGPROPERTY_WRITECHILDRENSEPARATE
Definition: GNEAttributeCarrier.h:309
GNEAttributeCarrier::AttributeProperties::isProbability
bool isProbability() const
return true if atribute is a probability
Definition: GNEAttributeCarrier.cpp:388
GNEAttributeCarrier::fillAttributeCarriers
static void fillAttributeCarriers()
fill Attribute Carriers
Definition: GNEAttributeCarrier.cpp:1460
SUMOXMLDefinitions::isValidAttribute
static bool isValidAttribute(const std::string &value)
whether the given string is a valid attribute for a certain key (for example, a name)
Definition: SUMOXMLDefinitions.cpp:995
SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:441
GNEAttributeCarrier::TagProperties::isPerson
bool isPerson() const
return true if tag correspond to a person element
Definition: GNEAttributeCarrier.cpp:756
SUMO_ATTR_OSGFILE
@ SUMO_ATTR_OSGFILE
Definition: SUMOXMLDefinitions.h:791
SUMO_TAG_WALK_FROMTO
@ SUMO_TAG_WALK_FROMTO
Definition: SUMOXMLDefinitions.h:307
SUMO_ATTR_TYPE
@ SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:381
ICON_EDGE
@ ICON_EDGE
Definition: GUIIcons.h:259
SUMO_ATTR_ANGLE
@ SUMO_ATTR_ANGLE
Definition: SUMOXMLDefinitions.h:794
SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_BOARDING_DURATION
Definition: SUMOXMLDefinitions.h:460
ICON_CONNECTION
@ ICON_CONNECTION
Definition: GUIIcons.h:261
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition: SUMOXMLDefinitions.h:590
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
GNEAttributeCarrier::TAGPROPERTY_SELECTABLE
@ TAGPROPERTY_SELECTABLE
Definition: GNEAttributeCarrier.h:306
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition: SUMOXMLDefinitions.h:1395
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition: SUMOXMLDefinitions.h:842
GNEAttributeCarrier::getIcon
FXIcon * getIcon() const
get FXIcon associated to this AC
Definition: GNEAttributeCarrier.cpp:1279
OptionsCont::getInt
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
Definition: OptionsCont.cpp:215
SUMO_ATTR_ACCELERATION
@ SUMO_ATTR_ACCELERATION
Definition: SUMOXMLDefinitions.h:892
GNEAttributeCarrier::GNEAttributeCarrier
GNEAttributeCarrier(const SumoXMLTag tag)
Constructor.
Definition: GNEAttributeCarrier.cpp:921
SUMO_ATTR_DEPART
@ SUMO_ATTR_DEPART
Definition: SUMOXMLDefinitions.h:431
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMO_TAG_LANECALIBRATOR
@ SUMO_TAG_LANECALIBRATOR
A calibrator placed over lane (used in netedit)
Definition: SUMOXMLDefinitions.h:93
GNEAttributeCarrier::AttributeProperties::isSUMOTime
bool isSUMOTime() const
return true if atribute is a SUMOTime
Definition: GNEAttributeCarrier.cpp:364
SUMOXMLDefinitions::isValidAdditionalID
static bool isValidAdditionalID(const std::string &value)
whether the given string is a valid id for an additional object
Definition: SUMOXMLDefinitions.cpp:984
SUMO_ATTR_HALTING_SPEED_THRESHOLD
@ SUMO_ATTR_HALTING_SPEED_THRESHOLD
Definition: SUMOXMLDefinitions.h:751
SUMO_TAG_STOP_PARKINGAREA
@ SUMO_TAG_STOP_PARKINGAREA
stop placed over a parking area (used in netedit)
Definition: SUMOXMLDefinitions.h:188
GNEAttributeCarrier::TagProperties
struct with the attribute Properties
Definition: GNEAttributeCarrier.h:317
SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
Definition: SUMOXMLDefinitions.h:617
GNEAttributeCarrier::dummyTagProperty
static TagProperties dummyTagProperty
dummy TagProperty used for reference some elements (for Example, dummyEdge)
Definition: GNEAttributeCarrier.h:791
GNEAttributeCarrier::ATTRPROPERTY_INT
@ ATTRPROPERTY_INT
Definition: GNEAttributeCarrier.h:67
GNEAttributeCarrier::mySelected
bool mySelected
boolean to check if this AC is selected (instead of GUIGlObjectStorage)
Definition: GNEAttributeCarrier.h:788
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:792
GNEAttributeCarrier::checkParsedAttribute
static bool checkParsedAttribute(const TagProperties &tagProperties, const AttributeProperties &attrProperties, const SumoXMLAttr attribute, std::string &defaultValue, std::string &parsedAttribute, std::string &warningMessage)
parse and check attribute (note: This function is only to improve legilibility)
Definition: GNEAttributeCarrier.cpp:4498
GNEAttributeCarrier::TagProperties::addDeprecatedAttribute
void addDeprecatedAttribute(SumoXMLAttr attr)
add deprecated Attribute
Definition: GNEAttributeCarrier.cpp:610
GNEAttributeCarrier::getID
const std::string getID() const
function to support debugging
Definition: GNEAttributeCarrier.cpp:1289
SUMO_ATTR_DISALLOW
@ SUMO_ATTR_DISALLOW
Definition: SUMOXMLDefinitions.h:783
StringUtils::toBool
static bool toBool(const std::string &sData)
converts a string into the bool value described by it by calling the char-type converter
Definition: StringUtils.cpp:374
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
GNEAttributeCarrier::TAGTYPE_VTYPE
@ TAGTYPE_VTYPE
Definition: GNEAttributeCarrier.h:281
GNEAttributeCarrier::TagProperties::isAdditional
bool isAdditional() const
return true if tag correspond to an additional
Definition: GNEAttributeCarrier.cpp:698
GNEAttributeCarrier::AttributeProperties::checkAttributeIntegrity
void checkAttributeIntegrity()
check Attribute integrity (For example, throw an exception if tag has a Float default value,...
Definition: GNEAttributeCarrier.cpp:106
SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_MINGAP_LAT
Definition: SUMOXMLDefinitions.h:444
SUMO_TAG_POLY
@ SUMO_TAG_POLY
begin/end of the description of a polygon
Definition: SUMOXMLDefinitions.h:57
NODETYPE_DEAD_END_DEPRECATED
@ NODETYPE_DEAD_END_DEPRECATED
Definition: SUMOXMLDefinitions.h:1070
RIGHT_OF_WAY_DEFAULT
@ RIGHT_OF_WAY_DEFAULT
Definition: SUMOXMLDefinitions.h:1105
SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_PARKING_AREA
Definition: SUMOXMLDefinitions.h:771
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition: SUMOXMLDefinitions.h:838
GNEAttributeCarrier::AttributeProperties::isposition
bool isposition() const
return true if atribute is a position
Definition: GNEAttributeCarrier.cpp:382
SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_CONTAINER_STOP
Definition: SUMOXMLDefinitions.h:770
ICON_TRIP
@ ICON_TRIP
Definition: GUIIcons.h:302
GNEAttributeCarrier::TagProperties::getTagStr
const std::string & getTagStr() const
get Tag vinculated with this attribute Property in String Format (used to avoid multiple calls to toS...
Definition: GNEAttributeCarrier.cpp:529
GNEAttributeCarrier::ATTRPROPERTY_COMPLEX
@ ATTRPROPERTY_COMPLEX
Definition: GNEAttributeCarrier.h:92
GNEAttributeCarrier::TagProperties::isPlacedInRTree
bool isPlacedInRTree() const
return true if Tag correspond to an element that has has to be placed in RTREE
Definition: GNEAttributeCarrier.cpp:865
SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_LATALIGNMENT
Definition: SUMOXMLDefinitions.h:443
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:393
GNEAttributeCarrier::TagProperties::isTAZ
bool isTAZ() const
return true if tag correspond to a TAZ
Definition: GNEAttributeCarrier.cpp:709
GNEAttributeCarrier::ATTRPROPERTY_UNIQUE
@ ATTRPROPERTY_UNIQUE
Definition: GNEAttributeCarrier.h:76
SUMO_TAG_STOP_LANE
@ SUMO_TAG_STOP_LANE
stop placed over a lane (used in netedit)
Definition: SUMOXMLDefinitions.h:180
SUMO_ATTR_TLTYPE
@ SUMO_ATTR_TLTYPE
node: the type of traffic light
Definition: SUMOXMLDefinitions.h:684
SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition: SUMOXMLDefinitions.h:589
GNEAttributeCarrier::TagProperties::canMaskStartEndPos
bool canMaskStartEndPos() const
return true if tag correspond to an element that can mask the attributes "start" and "end" position a...
Definition: GNEAttributeCarrier.cpp:895
GNEAttributeCarrier::ATTRPROPERTY_EXTENDED
@ ATTRPROPERTY_EXTENDED
Definition: GNEAttributeCarrier.h:89
SUMOXMLDefinitions::isValidFilename
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name)
Definition: SUMOXMLDefinitions.cpp:1001
SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDM_STEPPING
Definition: SUMOXMLDefinitions.h:837
GNEAttributeCarrier::TAGPROPERTY_SYNONYM
@ TAGPROPERTY_SYNONYM
Definition: GNEAttributeCarrier.h:304
GeomConvHelper.h
GNEAttributeCarrier::TagProperties::isStoppingPlace
bool isStoppingPlace() const
return true if tag correspond to a detector (Only used to group all stoppingPlaces in the output XML)
Definition: GNEAttributeCarrier.cpp:721
SUMO_ATTR_UNTIL
@ SUMO_ATTR_UNTIL
Definition: SUMOXMLDefinitions.h:668
ICON_PARKINGSPACE
@ ICON_PARKINGSPACE
Definition: GUIIcons.h:284
SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_MAXSPEED_LAT
Definition: SUMOXMLDefinitions.h:442
ICON_FLOW
@ ICON_FLOW
Definition: GUIIcons.h:303
GNEAttributeCarrier::AttributeProperties::isOptional
bool isOptional() const
return true if atribute is optional (it will be written in XML only if his value is different of defa...
Definition: GNEAttributeCarrier.cpp:448
GNEAttributeCarrier::ATTRPROPERTY_DEFAULTVALUEMUTABLE
@ ATTRPROPERTY_DEFAULTVALUEMUTABLE
Definition: GNEAttributeCarrier.h:85
GNEAttributeCarrier::parseIDs
static std::string parseIDs(const std::vector< T > &ACs)
parses a list of specific Attribute Carriers into a string of IDs
OptionsCont.h
GNEAttributeCarrier::fillCommonFlowAttributes
static void fillCommonFlowAttributes(SumoXMLTag currentTag)
fill common flow attributes (used by flows, routeFlows and personFlows)
Definition: GNEAttributeCarrier.cpp:4016
SUMO_ATTR_TMP2
@ SUMO_ATTR_TMP2
Definition: SUMOXMLDefinitions.h:551
SUMO_ATTR_LINE
@ SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:775
TLTYPE_STATIC
@ TLTYPE_STATIC
Definition: SUMOXMLDefinitions.h:1198
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:345
GNENet
A NBNetBuilder extended by visualisation and editing capabilities.
Definition: GNENet.h:77
GNEAttributeCarrier::TagProperties::isNetElement
bool isNetElement() const
return true if tag correspond to a netElement
Definition: GNEAttributeCarrier.cpp:692
ICON_EMPTY
@ ICON_EMPTY
Definition: GUIIcons.h:41
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
SUMO_ATTR_TO_LANE
@ SUMO_ATTR_TO_LANE
Definition: SUMOXMLDefinitions.h:720
GNEAttributeCarrier::ATTRPROPERTY_DISCRETE
@ ATTRPROPERTY_DISCRETE
Definition: GNEAttributeCarrier.h:78
SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_SPEEDFACTOR
Definition: SUMOXMLDefinitions.h:454
SUMO_TAG_WALK_ROUTE
@ SUMO_TAG_WALK_ROUTE
Definition: SUMOXMLDefinitions.h:309
ICON_STOPELEMENT
@ ICON_STOPELEMENT
Definition: GUIIcons.h:305
GNEAttributeCarrier::AttributeProperties::isPositive
bool isPositive() const
return true if atribute is positive
Definition: GNEAttributeCarrier.cpp:400
SUMO_TAG_TAZSOURCE
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
Definition: SUMOXMLDefinitions.h:135
SUMO_TAG_CONTAINER_STOP
@ SUMO_TAG_CONTAINER_STOP
A container stop.
Definition: SUMOXMLDefinitions.h:105
GNEAttributeCarrier::fillPersonStopElements
static void fillPersonStopElements()
fill PersonStop elements
Definition: GNEAttributeCarrier.cpp:3888
GNEAttributeCarrier::TagProperties::canBeSortedManually
bool canBeSortedManually() const
return true if Tag correspond to an element that can be sorted within their parent
Definition: GNEAttributeCarrier.cpp:871
SUMO_ATTR_CUSTOMSHAPE
@ SUMO_ATTR_CUSTOMSHAPE
whether a given shape is user-defined
Definition: SUMOXMLDefinitions.h:702
SUMO_ATTR_ARRIVALPOS_LAT
@ SUMO_ATTR_ARRIVALPOS_LAT
Definition: SUMOXMLDefinitions.h:438
SUMO_ATTR_OFF
@ SUMO_ATTR_OFF
Definition: SUMOXMLDefinitions.h:764
ICON_TAZ
@ ICON_TAZ
Definition: GUIIcons.h:292
GNEAttributeCarrier::TAGTYPE_DEMANDELEMENT
@ TAGTYPE_DEMANDELEMENT
Definition: GNEAttributeCarrier.h:277
GNEAttributeCarrier::fillShapes
static void fillShapes()
fill Shapes
Definition: GNEAttributeCarrier.cpp:2936
SUMO_ATTR_Z
@ SUMO_ATTR_Z
Definition: SUMOXMLDefinitions.h:400
SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
@ SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
Definition: SUMOXMLDefinitions.h:614
SUMO_ATTR_NUMLANES
@ SUMO_ATTR_NUMLANES
Definition: SUMOXMLDefinitions.h:383
SUMO_ATTR_TMP1
@ SUMO_ATTR_TMP1
Definition: SUMOXMLDefinitions.h:550
Shape::DEFAULT_LAYER
static const double DEFAULT_LAYER
Definition: Shape.h:43
SUMO_ATTR_PERIOD
@ SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:645
GNEAttributeCarrier::TagProperties::begin
std::vector< AttributeProperties >::const_iterator begin() const
get begin of attribute values (used for iterate)
Definition: GNEAttributeCarrier.cpp:636
StringBijection::getStrings
std::vector< std::string > getStrings() const
Definition: StringBijection.h:131
SUMOXMLDefinitions::RightOfWayValues
static StringBijection< RightOfWay > RightOfWayValues
righ of way algorithms
Definition: SUMOXMLDefinitions.h:1377
SUMO_TAG_PERSON
@ SUMO_TAG_PERSON
Definition: SUMOXMLDefinitions.h:295
SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition: SUMOXMLDefinitions.h:835
SUMO_TAG_LANE
@ SUMO_TAG_LANE
begin/end of the description of a single lane
Definition: SUMOXMLDefinitions.h:49
GNEAttributeCarrier::TAGPROPERTY_DIALOG
@ TAGPROPERTY_DIALOG
Definition: GNEAttributeCarrier.h:300
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
SUMO_ATTR_EDGE
@ SUMO_ATTR_EDGE
Definition: SUMOXMLDefinitions.h:423
GNEAttributeCarrier::TAGPROPERTY_NOPARAMETERS
@ TAGPROPERTY_NOPARAMETERS
Definition: GNEAttributeCarrier.h:310
ICON_PTYPE
@ ICON_PTYPE
Definition: GUIIcons.h:300
SUMO_ATTR_TLID
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
Definition: SUMOXMLDefinitions.h:682
SUMO_ATTR_LINES
@ SUMO_ATTR_LINES
Definition: SUMOXMLDefinitions.h:776
GNEAttributeCarrier::TagProperties::isRoute
bool isRoute() const
return true if tag correspond to a route element
Definition: GNEAttributeCarrier.cpp:744
GNEAttributeCarrier::AttributeProperties::isUnique
bool isUnique() const
return true if atribute is unique
Definition: GNEAttributeCarrier.cpp:442
NODETYPE_INTERNAL
@ NODETYPE_INTERNAL
Definition: SUMOXMLDefinitions.h:1068
GNEAttributeCarrier::AttributeProperties::getDefinition
const std::string & getDefinition() const
get default value
Definition: GNEAttributeCarrier.cpp:211
ICON_DESTPROBREROUTE
@ ICON_DESTPROBREROUTE
Definition: GUIIcons.h:289
SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_LOADING_DURATION
Definition: SUMOXMLDefinitions.h:461
GNEAttributeCarrier::AttributeProperties::isFloat
bool isFloat() const
return true if atribute is a float
Definition: GNEAttributeCarrier.cpp:358
SUMO_TAG_PTYPE
@ SUMO_TAG_PTYPE
description of a person type (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:123
GNEAttributeCarrier::TAGTYPE_ADDITIONAL
@ TAGTYPE_ADDITIONAL
Definition: GNEAttributeCarrier.h:275
GNEAttributeCarrier::ATTRPROPERTY_VCLASSES
@ ATTRPROPERTY_VCLASSES
Definition: GNEAttributeCarrier.h:86
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
GNEAttributeCarrier::AttributeProperties::setDiscreteValues
void setDiscreteValues(const std::vector< std::string > &discreteValues)
set discrete values
Definition: GNEAttributeCarrier.cpp:137
EmptyData
Definition: UtilExceptions.h:68
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
SUMO_TAG_POI
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
Definition: SUMOXMLDefinitions.h:53
GNEAttributeCarrier::TagProperties::isStop
bool isStop() const
return true if tag correspond to a stop element
Definition: GNEAttributeCarrier.cpp:750
GNEAttributeCarrier::ATTRPROPERTY_FLOWDEFINITION
@ ATTRPROPERTY_FLOWDEFINITION
Definition: GNEAttributeCarrier.h:93
GNEAttributeCarrier::TagProperties::end
std::vector< AttributeProperties >::const_iterator end() const
get end of attribute values (used for iterate)
Definition: GNEAttributeCarrier.cpp:642
GNEAttributeCarrier::TagProperties::isShape
bool isShape() const
return true if tag correspond to a shape
Definition: GNEAttributeCarrier.cpp:703
GNEAttributeCarrier::ATTRPROPERTY_VCLASS
@ ATTRPROPERTY_VCLASS
Definition: GNEAttributeCarrier.h:74
GNEAttributeCarrier::TagProperties::isVehicleType
bool isVehicleType() const
return true if tag correspond to a vehicle type element
Definition: GNEAttributeCarrier.cpp:733
GNEAttributeCarrier::TAGPROPERTY_MASKSTARTENDPOS
@ TAGPROPERTY_MASKSTARTENDPOS
Definition: GNEAttributeCarrier.h:307
SUMO_ATTR_SPEED
@ SUMO_ATTR_SPEED
Definition: SUMOXMLDefinitions.h:384
GNE_ATTR_SHAPE_END
@ GNE_ATTR_SHAPE_END
last coordinate of edge shape
Definition: SUMOXMLDefinitions.h:977
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:650
GNEAttributeCarrier::ATTRPROPERTY_OPTIONAL
@ ATTRPROPERTY_OPTIONAL
Definition: GNEAttributeCarrier.h:83
SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:437
SUMO_ATTR_SPEEDDEV
@ SUMO_ATTR_SPEEDDEV
Definition: SUMOXMLDefinitions.h:455
SUMO_ATTR_VISIBILITY_DISTANCE
@ SUMO_ATTR_VISIBILITY_DISTANCE
foe visibility distance of a link
Definition: SUMOXMLDefinitions.h:710
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
SUMO_TAG_DET_ENTRY
@ SUMO_TAG_DET_ENTRY
an e3 entry point
Definition: SUMOXMLDefinitions.h:81
SUMO_TAG_NOTHING
@ SUMO_TAG_NOTHING
invalid tag
Definition: SUMOXMLDefinitions.h:43
GNEAttributeCarrier::TagProperties::TagProperties
TagProperties()
default constructor
Definition: GNEAttributeCarrier.cpp:498
SUMO_ATTR_LANE
@ SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:637
ICON_WALK_EDGES
@ ICON_WALK_EDGES
Definition: GUIIcons.h:310
SUMO_ATTR_ROUTEPROBE
@ SUMO_ATTR_ROUTEPROBE
Definition: SUMOXMLDefinitions.h:670
GNEAttributeCarrier::TagProperties::hasGEOShape
bool hasGEOShape() const
return true if tag correspond to an element that can use a geo shape
Definition: GNEAttributeCarrier.cpp:828
GNEAttributeCarrier::ATTRPROPERTY_UPDATEGEOMETRY
@ ATTRPROPERTY_UPDATEGEOMETRY
Definition: GNEAttributeCarrier.h:90
GNEAttributeCarrier::TagProperties::checkTagIntegrity
void checkTagIntegrity() const
check Tag integrity (this include all their attributes)
Definition: GNEAttributeCarrier.cpp:535
ICON_LANE
@ ICON_LANE
Definition: GUIIcons.h:260
SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_IDM_DELTA
Definition: SUMOXMLDefinitions.h:836
SUMO_TAG_VTYPE
@ SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_CHARGING_STATION
Definition: SUMOXMLDefinitions.h:774
SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:798
PositionVector
A list of positions.
Definition: PositionVector.h:45
SUMO_ATTR_CHARGEINTRANSIT
@ SUMO_ATTR_CHARGEINTRANSIT
Allow/disallow charge in transit in Charging Stations.
Definition: SUMOXMLDefinitions.h:473
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition: SUMOXMLDefinitions.h:603
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition: SUMOXMLDefinitions.h:591
GUIIconSubSys::getIcon
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Definition: GUIIconSubSys.cpp:609
GNEAttributeCarrier::TagProperties::hasMinimumNumberOfChildren
bool hasMinimumNumberOfChildren() const
return true if tag correspond to an element that only have a limited number of children
Definition: GNEAttributeCarrier.cpp:852
SUMOXMLDefinitions::isValidDetectorID
static bool isValidDetectorID(const std::string &value)
whether the given string is a valid id for an detector
Definition: SUMOXMLDefinitions.cpp:989
SUMO_TAG_PARKING_SPACE
@ SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
Definition: SUMOXMLDefinitions.h:109
ICON_ROUTEPROBE
@ ICON_ROUTEPROBE
Definition: GUIIcons.h:279
SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_LANE_CHANGE_MODEL
Definition: SUMOXMLDefinitions.h:456
ICON_WALK_BUSSTOP
@ ICON_WALK_BUSSTOP
Definition: GUIIcons.h:312
SUMO_ATTR_TMP5
@ SUMO_ATTR_TMP5
Definition: SUMOXMLDefinitions.h:554
GNEAttributeCarrier::fillAdditionals
static void fillAdditionals()
fill Additionals
Definition: GNEAttributeCarrier.cpp:1870
SUMO_ATTR_TMP3
@ SUMO_ATTR_TMP3
Definition: SUMOXMLDefinitions.h:552
GNEAttributeCarrier::TagProperties::canWriteChildrenSeparate
bool canWriteChildrenSeparate() const
return true if tag correspond to an element that can sort their children automatic
Definition: GNEAttributeCarrier.cpp:889
GNEAttributeCarrier::ATTRPROPERTY_PROBABILITY
@ ATTRPROPERTY_PROBABILITY
Definition: GNEAttributeCarrier.h:79
SUMO_ATTR_SPREADTYPE
@ SUMO_ATTR_SPREADTYPE
The information about how to spread the lanes from the given position.
Definition: SUMOXMLDefinitions.h:692
SUMO_ATTR_FILE
@ SUMO_ATTR_FILE
Definition: SUMOXMLDefinitions.h:664
FALLTHROUGH
#define FALLTHROUGH
Definition: StdDefs.h:36
SUMO_ATTR_DIR
@ SUMO_ATTR_DIR
The abstract direction of a link.
Definition: SUMOXMLDefinitions.h:706
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
GNEAttributeCarrier::fillDemandElements
static void fillDemandElements()
fill Demand Elements
Definition: GNEAttributeCarrier.cpp:3144
GNEAttributeCarrier::AttributeProperties::requireUpdateGeometry
bool requireUpdateGeometry() const
return true if atribute requires a update geometry in setAttribute(...)
Definition: GNEAttributeCarrier.cpp:472
GNEAttributeCarrier::TAGPROPERTY_MASKXYZPOSITION
@ TAGPROPERTY_MASKXYZPOSITION
Definition: GNEAttributeCarrier.h:308
SUMO_ATTR_JM_IGNORE_FOE_PROB
@ SUMO_ATTR_JM_IGNORE_FOE_PROB
Definition: SUMOXMLDefinitions.h:619
GNEAttributeCarrier::TAGPROPERTY_CENTERAFTERCREATION
@ TAGPROPERTY_CENTERAFTERCREATION
Definition: GNEAttributeCarrier.h:313
GNEAttributeCarrier::ATTRPROPERTY_FLOAT
@ ATTRPROPERTY_FLOAT
Definition: GNEAttributeCarrier.h:68
SUMO_ATTR_JM_TIMEGAP_MINOR
@ SUMO_ATTR_JM_TIMEGAP_MINOR
Definition: SUMOXMLDefinitions.h:621
GNEAttributeCarrier::TagProperties::getTag
SumoXMLTag getTag() const
get Tag vinculated with this attribute Property
Definition: GNEAttributeCarrier.cpp:523
GNEAttributeCarrier::AttributeProperties::isList
bool isList() const
return true if atribute is a list
Definition: GNEAttributeCarrier.cpp:430
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
SUMO_ATTR_WEIGHT
@ SUMO_ATTR_WEIGHT
Definition: SUMOXMLDefinitions.h:421
GNEAttributeCarrier::ATTRPROPERTY_DEFAULTVALUESTATIC
@ ATTRPROPERTY_DEFAULTVALUESTATIC
Definition: GNEAttributeCarrier.h:84
SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
Definition: SUMOXMLDefinitions.h:618
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:678
SVS_UNKNOWN
@ SVS_UNKNOWN
not defined
Definition: SUMOVehicleClass.h:52
GNEAttributeCarrier::TAGTYPE_PERSONTRIP
@ TAGTYPE_PERSONTRIP
Definition: GNEAttributeCarrier.h:287
GNEJunction.h
SUMO_ATTR_TO
@ SUMO_ATTR_TO
Definition: SUMOXMLDefinitions.h:640
Shape::DEFAULT_IMG_HEIGHT
static const double DEFAULT_IMG_HEIGHT
Definition: Shape.h:50
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition: SUMOXMLDefinitions.h:1398
SUMO_ATTR_CHARGEDELAY
@ SUMO_ATTR_CHARGEDELAY
Delay in the charge of charging stations.
Definition: SUMOXMLDefinitions.h:475
SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_PUSHYGAP
Definition: SUMOXMLDefinitions.h:595
GNEAttributeCarrier::parseMaskedPositionAttribute
static bool parseMaskedPositionAttribute(const SUMOSAXAttributes &attrs, const std::string &objectID, const TagProperties &tagProperties, const AttributeProperties &attrProperties, std::string &parsedAttribute, std::string &warningMessage)
parse and check masked (note: This function is only to improve legilibility)
Definition: GNEAttributeCarrier.cpp:4676
GNEAttributeCarrier::TagProperties::hasAttribute
bool hasAttribute(SumoXMLAttr attr) const
check if current TagProperties owns the attribute attr
Definition: GNEAttributeCarrier.cpp:680
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition: SUMOXMLDefinitions.h:602
GNEEdge
A road/street connecting two junctions (netedit-version)
Definition: GNEEdge.h:51
GNEAttributeCarrier::ATTRPROPERTY_SYNONYM
@ ATTRPROPERTY_SYNONYM
Definition: GNEAttributeCarrier.h:87
GNEAttributeCarrier::TagProperties::canAutomaticSortChildren
bool canAutomaticSortChildren() const
return true if tag correspond to an element that can sort their children automatic
Definition: GNEAttributeCarrier.cpp:883
SUMO_ATTR_PERSON_NUMBER
@ SUMO_ATTR_PERSON_NUMBER
Definition: SUMOXMLDefinitions.h:651
SUMO_TAG_PARKING_ZONE_REROUTE
@ SUMO_TAG_PARKING_ZONE_REROUTE
entry for an alternative parking zone
Definition: SUMOXMLDefinitions.h:198
GNEAttributeCarrier::TagProperties::getTagSynonym
SumoXMLTag getTagSynonym() const
get tag synonym
Definition: GNEAttributeCarrier.cpp:670
GNEAttributeCarrier::TAGTYPE_VEHICLE
@ TAGTYPE_VEHICLE
Definition: GNEAttributeCarrier.h:282
GNE_ATTR_SHAPE_START
@ GNE_ATTR_SHAPE_START
first coordinate of edge shape
Definition: SUMOXMLDefinitions.h:975
NumberFormatException
Definition: UtilExceptions.h:95
Shape::DEFAULT_RELATIVEPATH
static const bool DEFAULT_RELATIVEPATH
Definition: Shape.h:48
SUMO_TAG_WALK_EDGES
@ SUMO_TAG_WALK_EDGES
Definition: SUMOXMLDefinitions.h:306
GNEAttributeCarrier::TagProperties::isVehicle
bool isVehicle() const
return true if tag correspond to a vehicle element
Definition: GNEAttributeCarrier.cpp:739
SUMO_TAG_DEST_PROB_REROUTE
@ SUMO_TAG_DEST_PROB_REROUTE
probability of destiny of a reroute
Definition: SUMOXMLDefinitions.h:190
SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_LCA_SUBLANE_PARAM
Definition: SUMOXMLDefinitions.h:592
GNEAttributeCarrier::FEATURE_GUESSED
static const std::string FEATURE_GUESSED
feature has been reguessed (may still be unchanged be we can't tell (yet)
Definition: GNEAttributeCarrier.h:595
GNEAttributeCarrier::fillCommonVehicleAttributes
static void fillCommonVehicleAttributes(SumoXMLTag currentTag)
fill common vehicle attributes (used by vehicles, trips, routeFlows and flows)
Definition: GNEAttributeCarrier.cpp:3938
GNEAttributeCarrier::AttributeProperties::AttributeProperties
AttributeProperties()
default constructor
Definition: GNEAttributeCarrier.cpp:57
RGBColor
Definition: RGBColor.h:39
SUMO_ATTR_LINEWIDTH
@ SUMO_ATTR_LINEWIDTH
Definition: SUMOXMLDefinitions.h:715
SUMO_TAG_ROUTEFLOW
@ SUMO_TAG_ROUTEFLOW
a flow definition nusing a route instead of a from-to edges route (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:151
SUMO_ATTR_ARRIVALSPEED
@ SUMO_ATTR_ARRIVALSPEED
Definition: SUMOXMLDefinitions.h:439
GNEAttributeCarrier::ATTRPROPERTY_POSITION
@ ATTRPROPERTY_POSITION
Definition: GNEAttributeCarrier.h:72
SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_APPARENTDECEL
Definition: SUMOXMLDefinitions.h:448
ICON_E3EXIT
@ ICON_E3EXIT
Definition: GUIIcons.h:276
GNEAttributeCarrier::AttributeProperties::isFlowDefinition
bool isFlowDefinition() const
return true if atribute is part of a flow definition
Definition: GNEAttributeCarrier.cpp:490
canParseVehicleClasses
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
Definition: SUMOVehicleClass.cpp:251
GNEAttributeCarrier::TagProperties::isAttributeDeprecated
bool isAttributeDeprecated(SumoXMLAttr attr) const
return true if attribute of this tag is deprecated
Definition: GNEAttributeCarrier.cpp:913
SUMO_ATTR_CHARGINGPOWER
@ SUMO_ATTR_CHARGINGPOWER
Definition: SUMOXMLDefinitions.h:469
GNEAttributeCarrier::TagProperties::canBlockShape
bool canBlockShape() const
return true if tag correspond to an element that can block their shape
Definition: GNEAttributeCarrier.cpp:810
SUMO_TAG_FLOW
@ SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
Definition: SUMOXMLDefinitions.h:149
ICON_CHARGINGSTATION
@ ICON_CHARGINGSTATION
Definition: GUIIcons.h:271
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:629
SUMO_ATTR_DECEL
@ SUMO_ATTR_DECEL
Definition: SUMOXMLDefinitions.h:446
GNEAttributeCarrier::AttributeProperties::isFilename
bool isFilename() const
return true if atribute is a filename
Definition: GNEAttributeCarrier.cpp:412
GNEAttributeCarrier::AttributeProperties::isActivatable
bool isActivatable() const
return true if atribute is activatable
Definition: GNEAttributeCarrier.cpp:478
GNEAttributeCarrier::getTagProperty
const TagProperties & getTagProperty() const
get Tag Property assigned to this object
Definition: GNEAttributeCarrier.cpp:1273
SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition: SUMOXMLDefinitions.h:459
SUMO_ATTR_STARTPOS
@ SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:797
GNEAttributeCarrier::fillStopElements
static void fillStopElements()
fill Stop elements
Definition: GNEAttributeCarrier.cpp:3582
SUMO_TAG_CHARGING_STATION
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
Definition: SUMOXMLDefinitions.h:111
SUMO_TAG_STOP_CHARGINGSTATION
@ SUMO_TAG_STOP_CHARGINGSTATION
stop placed over a charging station (used in netedit)
Definition: SUMOXMLDefinitions.h:186
ICON_VAPORIZER
@ ICON_VAPORIZER
Definition: GUIIcons.h:280
SUMO_ATTR_ACCEL
@ SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:445
GNEAttributeCarrier::ATTRPROPERTY_RANGE
@ ATTRPROPERTY_RANGE
Definition: GNEAttributeCarrier.h:88
GNEAttributeCarrier::lanesConsecutives
static bool lanesConsecutives(const std::vector< GNELane * > &lanes)
check if lanes are consecutives
Definition: GNEAttributeCarrier.cpp:1136
SUMO_ATTR_KEEP_CLEAR
@ SUMO_ATTR_KEEP_CLEAR
Whether vehicles must keep the junction clear.
Definition: SUMOXMLDefinitions.h:696
GNEAttributeCarrier::AttributeProperties
struct with the attribute Properties
Definition: GNEAttributeCarrier.h:97
PollutantsInterface.h
GNEAttributeCarrier::AttributeProperties::isColor
bool isColor() const
return true if atribute is a color
Definition: GNEAttributeCarrier.cpp:406
GNEAttributeCarrier::allowedTagsByCategory
static std::vector< SumoXMLTag > allowedTagsByCategory(int tagPropertyCategory, bool onlyDrawables)
get tags of all editable element types using TagProperty Type (TAGTYPE_NETELEMENT,...
Definition: GNEAttributeCarrier.cpp:1333
SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition: SUMOXMLDefinitions.h:593
SUMO_TAG_POILANE
@ SUMO_TAG_POILANE
begin/end of the description of a Point of interest over Lane (used by Netedit)
Definition: SUMOXMLDefinitions.h:55
SUMO_TAG_VSS
@ SUMO_TAG_VSS
A variable speed sign.
Definition: SUMOXMLDefinitions.h:89
SUMO_TAG_PERSONSTOP_LANE
@ SUMO_TAG_PERSONSTOP_LANE
Definition: SUMOXMLDefinitions.h:313
NBEdge::UNSPECIFIED_CONTPOS
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition: NBEdge.h:324
GNEAttributeCarrier::TAGPROPERTY_GEOSHAPE
@ TAGPROPERTY_GEOSHAPE
Definition: GNEAttributeCarrier.h:299
SUMO_ATTR_PASS
@ SUMO_ATTR_PASS
Definition: SUMOXMLDefinitions.h:768
GNEAttributeCarrier::TAGPROPERTY_RTREE
@ TAGPROPERTY_RTREE
Definition: GNEAttributeCarrier.h:311
SUMO_ATTR_TLLINKINDEX2
@ SUMO_ATTR_TLLINKINDEX2
link: the index of the opposite direction link of a pedestrian crossing
Definition: SUMOXMLDefinitions.h:688
GNEAttributeCarrier::fillPersonElements
static void fillPersonElements()
fill Person Elements
Definition: GNEAttributeCarrier.cpp:3673
ICON_ACCESS
@ ICON_ACCESS
Definition: GUIIcons.h:269
SUMOVehicleShape
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
Definition: SUMOVehicleClass.h:50
StringTokenizer
Definition: StringTokenizer.h:61
GNEAttributeCarrier::TagProperties::isDemandElement
bool isDemandElement() const
return true if tag correspond to a demand element
Definition: GNEAttributeCarrier.cpp:715
SUMO_ATTR_NOTHING
@ SUMO_ATTR_NOTHING
invalid attribute
Definition: SUMOXMLDefinitions.h:374
ICON_VEHICLE
@ ICON_VEHICLE
Definition: GUIIcons.h:301
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
SUMO_ATTR_DEPARTPOS_LAT
@ SUMO_ATTR_DEPARTPOS_LAT
Definition: SUMOXMLDefinitions.h:434
GNEAttributeCarrier::TagProperties::hasGEOPosition
bool hasGEOPosition() const
return true if tag correspond to an element that can use a geo position
Definition: GNEAttributeCarrier.cpp:822
RGBColor::parseColor
static RGBColor parseColor(std::string coldef)
Parses a color information.
Definition: RGBColor.cpp:176
ICON_LOCATEPOI
@ ICON_LOCATEPOI
Definition: GUIIcons.h:83
SUMO_ATTR_LCA_SPEEDGAINRIGHT
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition: SUMOXMLDefinitions.h:601
GNEAttributeCarrier::TAGTYPE_ROUTE
@ TAGTYPE_ROUTE
Definition: GNEAttributeCarrier.h:283
SUMO_ATTR_CONT
@ SUMO_ATTR_CONT
Definition: SUMOXMLDefinitions.h:748
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:386
SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:435
SUMO_ATTR_ROUTE
@ SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:440
SUMO_ATTR_EDGES
@ SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:427
GNEAttributeCarrier::ATTRPROPERTY_LIST
@ ATTRPROPERTY_LIST
Definition: GNEAttributeCarrier.h:81
SUMO_ATTR_DEPARTLANE
@ SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:432
SUMO_TAG_PARKING_AREA
@ SUMO_TAG_PARKING_AREA
A parking area.
Definition: SUMOXMLDefinitions.h:107
ICON_E2
@ ICON_E2
Definition: GUIIcons.h:273
SUMO_ATTR_JM_DRIVE_RED_SPEED
@ SUMO_ATTR_JM_DRIVE_RED_SPEED
Definition: SUMOXMLDefinitions.h:616
GNEAttributeCarrier::TAGTYPE_TAZ
@ TAGTYPE_TAZ
Definition: GNEAttributeCarrier.h:278
SUMO_ATTR_LAYER
@ SUMO_ATTR_LAYER
A layer number.
Definition: SUMOXMLDefinitions.h:712
SUMO_TAG_EDGE
@ SUMO_TAG_EDGE
begin/end of the description of an edge
Definition: SUMOXMLDefinitions.h:47
GNEAttributeCarrier::ATTRPROPERTY_SUMOTIME
@ ATTRPROPERTY_SUMOTIME
Definition: GNEAttributeCarrier.h:69
ICON_PERSONTRIP_BUSSTOP
@ ICON_PERSONTRIP_BUSSTOP
Definition: GUIIcons.h:309
SUMO_ATTR_TRIGGERED
@ SUMO_ATTR_TRIGGERED
Definition: SUMOXMLDefinitions.h:799
GNEAttributeCarrier::TAGPROPERTY_AUTOMATICSORTING
@ TAGPROPERTY_AUTOMATICSORTING
Definition: GNEAttributeCarrier.h:305
GNEAttributeCarrier::TagProperties::getParentTag
SumoXMLTag getParentTag() const
if Tag owns a parent, return parent tag
Definition: GNEAttributeCarrier.cpp:660
GNEAttributeCarrier::TAGPROPERTY_GEOPOSITION
@ TAGPROPERTY_GEOPOSITION
Definition: GNEAttributeCarrier.h:298
ProcessError
Definition: UtilExceptions.h:39
SUMO_TAG_STEP
@ SUMO_TAG_STEP
trigger: a step description
Definition: SUMOXMLDefinitions.h:157
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:649
ICON_LOCATEPOLY
@ ICON_LOCATEPOLY
Definition: GUIIcons.h:84
GNEAttributeCarrier::TagProperties::addAttribute
void addAttribute(const AttributeProperties &attributeProperty)
add attribute (duplicated attributed aren't allowed)
Definition: GNEAttributeCarrier.cpp:590
Shape::DEFAULT_TYPE
static const std::string DEFAULT_TYPE
Definition: Shape.h:42
SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition: SUMOXMLDefinitions.h:600
GNEAttributeCarrier::AttributeProperties::setTagPropertyParent
void setTagPropertyParent(TagProperties *tagPropertyParent)
set tag property parent
Definition: GNEAttributeCarrier.cpp:176
SUMO_ATTR_CONTAINER_NUMBER
@ SUMO_ATTR_CONTAINER_NUMBER
Definition: SUMOXMLDefinitions.h:652
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
GNEAttributeCarrier::myTagProperties
static std::map< SumoXMLTag, TagProperties > myTagProperties
map with the tags properties
Definition: GNEAttributeCarrier.h:857
SUMO_TAG_ROUTE_PROB_REROUTE
@ SUMO_TAG_ROUTE_PROB_REROUTE
probability of route of a reroute
Definition: SUMOXMLDefinitions.h:196
GNEEdge.h
GNEAttributeCarrier::AttributeProperties::getAttrStr
const std::string & getAttrStr() const
get XML Attribute
Definition: GNEAttributeCarrier.cpp:188
GNEAttributeCarrier::myTagProperty
const TagProperties & myTagProperty
the xml tag to which this attribute carrier corresponds
Definition: GNEAttributeCarrier.h:785
SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition: SUMOXMLDefinitions.h:605
GNEAttributeCarrier::AttributeProperties::getDefaultValue
const std::string & getDefaultValue() const
get default value
Definition: GNEAttributeCarrier.cpp:217
GNEAttributeCarrier::ATTRPROPERTY_STRING
@ ATTRPROPERTY_STRING
Definition: GNEAttributeCarrier.h:71
GNEAttributeCarrier::TAGPROPERTY_MINIMUMCHILDREN
@ TAGPROPERTY_MINIMUMCHILDREN
Definition: GNEAttributeCarrier.h:302
ICON_CROSSING
@ ICON_CROSSING
Definition: GUIIcons.h:263
GNEAttributeCarrier::TagProperties::canBeReparent
bool canBeReparent() const
return true if tag correspond to an element that can be reparent
Definition: GNEAttributeCarrier.cpp:877
SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition: SUMOXMLDefinitions.h:588
GNEAttributeCarrier::AttributeProperties::getMinimumRange
double getMinimumRange() const
get minimum range
Definition: GNEAttributeCarrier.cpp:309
SUMO_ATTR_Y
@ SUMO_ATTR_Y
Definition: SUMOXMLDefinitions.h:399
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_JM_SIGMA_MINOR
Definition: SUMOXMLDefinitions.h:620
GNEAttributeCarrier::TagProperties::isWalk
bool isWalk() const
return true if tag correspond to a walk element
Definition: GNEAttributeCarrier.cpp:774
SUMO_TAG_REROUTER
@ SUMO_TAG_REROUTER
A rerouter.
Definition: SUMOXMLDefinitions.h:95
ICON_E3
@ ICON_E3
Definition: GUIIcons.h:274
NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition: NBEdge.h:327
SUMO_TAG_PERSONTRIP_BUSSTOP
@ SUMO_TAG_PERSONTRIP_BUSSTOP
Definition: SUMOXMLDefinitions.h:305
GNEAttributeCarrier::ATTRPROPERTY_ANGLE
@ ATTRPROPERTY_ANGLE
Definition: GNEAttributeCarrier.h:80
GNEAttributeCarrier::getAlternativeValueForDisabledAttributes
std::string getAlternativeValueForDisabledAttributes(SumoXMLAttr key) const
Definition: GNEAttributeCarrier.cpp:1167
GNEAttributeCarrier::AttributeProperties::~AttributeProperties
~AttributeProperties()
destructor
Definition: GNEAttributeCarrier.cpp:102
GNEAttributeCarrier::fillVehicleElements
static void fillVehicleElements()
fill vehicle elements
Definition: GNEAttributeCarrier.cpp:3433
GNEAttributeCarrier::AttributeProperties::getAttr
SumoXMLAttr getAttr() const
get XML Attribute
Definition: GNEAttributeCarrier.cpp:182
GUIIcon
GUIIcon
An enumeration of icons used by the gui applications.
Definition: GUIIcons.h:35
FormatException
Definition: UtilExceptions.h:81
SUMO_ATTR_DISTANCE
@ SUMO_ATTR_DISTANCE
Definition: SUMOXMLDefinitions.h:395
GNEAttributeCarrier::AttributeProperties::isSecuential
bool isSecuential() const
return true if atribute is sequential
Definition: GNEAttributeCarrier.cpp:436
GNEAttributeCarrier::AttributeProperties::isVClass
bool isVClass() const
return true if atribute is a VehicleClass
Definition: GNEAttributeCarrier.cpp:418
NBEdge::UNSPECIFIED_SPEED
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:321
ICON_ROUTEFLOW
@ ICON_ROUTEFLOW
Definition: GUIIcons.h:304
SUMO_TAG_CLOSING_REROUTE
@ SUMO_TAG_CLOSING_REROUTE
reroute of type closing
Definition: SUMOXMLDefinitions.h:192
GNEAttributeCarrier::AttributeProperties::getMaximumRange
double getMaximumRange() const
get maximum range
Definition: GNEAttributeCarrier.cpp:319
SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_LCA_IMPATIENCE
Definition: SUMOXMLDefinitions.h:597
SUMO_TAG_VEHICLE
@ SUMO_TAG_VEHICLE
description of a vehicle
Definition: SUMOXMLDefinitions.h:119
SUMO_ATTR_TIME
@ SUMO_ATTR_TIME
trigger: the time of the step
Definition: SUMOXMLDefinitions.h:676
SUMO_ATTR_RELATIVEPATH
@ SUMO_ATTR_RELATIVEPATH
Definition: SUMOXMLDefinitions.h:793
SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_FRIENDLY_POS
Definition: SUMOXMLDefinitions.h:765
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:44
GNEAttributeCarrier::TAGPROPERTY_BLOCKSHAPE
@ TAGPROPERTY_BLOCKSHAPE
Definition: GNEAttributeCarrier.h:296
SUMO_ATTR_EXTENSION
@ SUMO_ATTR_EXTENSION
Definition: SUMOXMLDefinitions.h:669
GNELane.h
ICON_PERSONFLOW
@ ICON_PERSONFLOW
Definition: GUIIcons.h:307
GNEAttributeCarrier::TAGTYPE_DETECTOR
@ TAGTYPE_DETECTOR
Definition: GNEAttributeCarrier.h:280
GNEAttributeCarrier::AttributeProperties::getTagPropertyParent
const TagProperties & getTagPropertyParent() const
get reference to tagProperty parent
Definition: GNEAttributeCarrier.cpp:194
ICON_VTYPE
@ ICON_VTYPE
Definition: GUIIcons.h:299
GNEAttributeCarrier::TagProperties::canCenterCameraAfterCreation
bool canCenterCameraAfterCreation() const
return true if tag correspond to an element that center camera after creation
Definition: GNEAttributeCarrier.cpp:907
SUMO_ATTR_FREQUENCY
@ SUMO_ATTR_FREQUENCY
Definition: SUMOXMLDefinitions.h:662
SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_LCA_ASSERTIVE
Definition: SUMOXMLDefinitions.h:596
GNEAttributeCarrier::TAGPROPERTY_PARENT
@ TAGPROPERTY_PARENT
Definition: GNEAttributeCarrier.h:301
GNEAttributeCarrier::ATTRPROPERTY_SECUENCIAL
@ ATTRPROPERTY_SECUENCIAL
Definition: GNEAttributeCarrier.h:82
SUMO_ATTR_POSITION
@ SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:660
NODETYPE_DEAD_END
@ NODETYPE_DEAD_END
Definition: SUMOXMLDefinitions.h:1069
SUMO_ATTR_FILL
@ SUMO_ATTR_FILL
Fill the polygon.
Definition: SUMOXMLDefinitions.h:714
ICON_E1INSTANT
@ ICON_E1INSTANT
Definition: GUIIcons.h:277
GNEAttributeCarrier::AttributeProperties::hasMutableDefaultValue
bool hasMutableDefaultValue() const
return true if attribute owns a mutable default value
Definition: GNEAttributeCarrier.cpp:335
SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition: SUMOXMLDefinitions.h:841
GNEAttributeCarrier::AttributeProperties::hasStaticDefaultValue
bool hasStaticDefaultValue() const
return true if attribute owns a static default value
Definition: GNEAttributeCarrier.cpp:329
SUMO_ATTR_FROM_LANE
@ SUMO_ATTR_FROM_LANE
Definition: SUMOXMLDefinitions.h:719
SUMO_ATTR_INDEX
@ SUMO_ATTR_INDEX
Definition: SUMOXMLDefinitions.h:804
SUMO_TAG_E2DETECTOR_MULTILANE
@ SUMO_TAG_E2DETECTOR_MULTILANE
an e2 detector over multiple lanes (used by Netedit)
Definition: SUMOXMLDefinitions.h:69
GNEAttributeCarrier::TagProperties::~TagProperties
~TagProperties()
destructor
Definition: GNEAttributeCarrier.cpp:519
SUMO_ATTR_FROM
@ SUMO_ATTR_FROM
Definition: SUMOXMLDefinitions.h:639
GNEAttributeCarrier::ATTRPROPERTY_FILENAME
@ ATTRPROPERTY_FILENAME
Definition: GNEAttributeCarrier.h:77
GNEAttributeCarrier::INVALID_POSITION
static const double INVALID_POSITION
invalid double position
Definition: GNEAttributeCarrier.h:608
SUMO_ATTR_CARRIAGE_GAP
@ SUMO_ATTR_CARRIAGE_GAP
Definition: SUMOXMLDefinitions.h:1016
SUMO_ATTR_RADIUS
@ SUMO_ATTR_RADIUS
The turning radius at an intersection in m.
Definition: SUMOXMLDefinitions.h:694
GNEAttributeCarrier::parse
static T parse(const std::string &string)
parses a value of type T from string (used for basic types: int, double, bool, etc....
SUMO_ATTR_LANES
@ SUMO_ATTR_LANES
Definition: SUMOXMLDefinitions.h:638
GNEAttributeCarrier::AttributeProperties::isDiscrete
bool isDiscrete() const
return true if atribute is discrete
Definition: GNEAttributeCarrier.cpp:454
SUMO_TAG_TAZ
@ SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:133
GNEAttributeCarrier::TagProperties::isPersonTrip
bool isPersonTrip() const
return true if tag correspond to a person trip
Definition: GNEAttributeCarrier.cpp:768
GNEAttributeCarrier::TAGTYPE_STOP
@ TAGTYPE_STOP
Definition: GNEAttributeCarrier.h:284
SUMO_ATTR_JM_CROSSING_GAP
@ SUMO_ATTR_JM_CROSSING_GAP
Definition: SUMOXMLDefinitions.h:613
ICON_PARKINGZONEREROUTE
@ ICON_PARKINGZONEREROUTE
Definition: GUIIcons.h:290
GNEAttributeCarrier::fillCommonStopAttributes
static void fillCommonStopAttributes(SumoXMLTag currentTag)
fill stop person attributes (used by stops and personStps)
Definition: GNEAttributeCarrier.cpp:4426
SumoVehicleShapeStrings
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false)
OptionsCont::getFloat
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
Definition: OptionsCont.cpp:208
GNEAttributeCarrier::TAGPROPERTY_BLOCKMOVEMENT
@ TAGPROPERTY_BLOCKMOVEMENT
Definition: GNEAttributeCarrier.h:295
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:789
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GNEAttributeCarrier::fillCarFollowingModelAttributes
static void fillCarFollowingModelAttributes(SumoXMLTag currentTag)
fill Car Following Model of Vehicle/Person Types
Definition: GNEAttributeCarrier.cpp:4059
GNEAttributeCarrier::TagProperties::isPersonPlan
bool isPersonPlan() const
return true if tag correspond to a person plan
Definition: GNEAttributeCarrier.cpp:762
GNEAttributeCarrier::TagProperties::isSelectable
bool isSelectable() const
return true if tag correspond to a selectable element
Definition: GNEAttributeCarrier.cpp:798
SUMO_TAG_BUS_STOP
@ SUMO_TAG_BUS_STOP
A bus stop.
Definition: SUMOXMLDefinitions.h:97
SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition: SUMOXMLDefinitions.h:834
GNEAttributeCarrier::ATTRPROPERTY_ACTIVATABLE
@ ATTRPROPERTY_ACTIVATABLE
Definition: GNEAttributeCarrier.h:91
SUMO_TAG_TAZSINK
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
Definition: SUMOXMLDefinitions.h:137
SUMO_ATTR_STATE
@ SUMO_ATTR_STATE
The state of a link.
Definition: SUMOXMLDefinitions.h:708
GNEAttributeCarrier::TagProperties::getDefaultValue
const std::string & getDefaultValue(SumoXMLAttr attr) const
return the default value of the attribute of an element
Definition: GNEAttributeCarrier.cpp:574
SUMO_TAG_STOP_CONTAINERSTOP
@ SUMO_TAG_STOP_CONTAINERSTOP
stop placed over a containerStop (used in netedit)
Definition: SUMOXMLDefinitions.h:184
StringUtils::toInt
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
Definition: StringUtils.cpp:278
GNEAttributeCarrier::allowedTags
static std::vector< SumoXMLTag > allowedTags(bool onlyDrawables)
get tags of all editable element types
Definition: GNEAttributeCarrier.cpp:1316
SUMO_ATTR_PRIORITY
@ SUMO_ATTR_PRIORITY
Definition: SUMOXMLDefinitions.h:382
SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_TRAIN_TYPE
Definition: SUMOXMLDefinitions.h:583
SUMO_ATTR_DURATION
@ SUMO_ATTR_DURATION
Definition: SUMOXMLDefinitions.h:667
GNEAttributeCarrier::AttributeProperties::isVClasses
bool isVClasses() const
return true if atribute is a list of VClasses
Definition: GNEAttributeCarrier.cpp:460
SUMO_ATTR_VIA
@ SUMO_ATTR_VIA
Definition: SUMOXMLDefinitions.h:723
ICON_PARKINGAREA
@ ICON_PARKINGAREA
Definition: GUIIcons.h:283
SUMO_ATTR_ROADSIDE_CAPACITY
@ SUMO_ATTR_ROADSIDE_CAPACITY
Definition: SUMOXMLDefinitions.h:772
SUMO_ATTR_SIGMA
@ SUMO_ATTR_SIGMA
Definition: SUMOXMLDefinitions.h:548
SUMO_TAG_CROSSING
@ SUMO_TAG_CROSSING
crossing between edges for pedestrians
Definition: SUMOXMLDefinitions.h:226
SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
Definition: SUMOXMLDefinitions.h:750
GNEAttributeCarrier::TAGTYPE_PERSONPLAN
@ TAGTYPE_PERSONPLAN
Definition: GNEAttributeCarrier.h:286
GNEAttributeCarrier::AttributeProperties::getDiscreteValues
const std::vector< std::string > & getDiscreteValues() const
get discrete values
Definition: GNEAttributeCarrier.cpp:293
SUMO_TAG_FLOW_CALIBRATOR
@ SUMO_TAG_FLOW_CALIBRATOR
a flow definition within in Calibrator (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:153
SUMO_ATTR_OUTPUT
@ SUMO_ATTR_OUTPUT
Definition: SUMOXMLDefinitions.h:788
TimeFormatException
Definition: UtilExceptions.h:108
SUMO_ATTR_EXPECTED
@ SUMO_ATTR_EXPECTED
Definition: SUMOXMLDefinitions.h:802
GNEAttributeCarrier::TagProperties::isPersonStop
bool isPersonStop() const
return true if tag correspond to a person stop element
Definition: GNEAttributeCarrier.cpp:786
SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CAR_FOLLOW_MODEL
Definition: SUMOXMLDefinitions.h:457
ICON_TAZEDGE
@ ICON_TAZEDGE
Definition: GUIIcons.h:293
GNEAttributeCarrier::TagProperties::hasTagSynonym
bool hasTagSynonym() const
return true if tag correspond to an element that will be written in XML with another tag
Definition: GNEAttributeCarrier.cpp:840
ICON_RIDE_FROMTO
@ ICON_RIDE_FROMTO
Definition: GUIIcons.h:314
SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_IMPATIENCE
Definition: SUMOXMLDefinitions.h:796
GNEAttributeCarrier::TAGTYPE_PERSONSTOP
@ TAGTYPE_PERSONSTOP
Definition: GNEAttributeCarrier.h:290
ICON_E1
@ ICON_E1
Definition: GUIIcons.h:272
SUMO_ATTR_TLLINKINDEX
@ SUMO_ATTR_TLLINKINDEX
link: the index of the link within the traffic light
Definition: SUMOXMLDefinitions.h:686
SUMO_ATTR_VTYPES
@ SUMO_ATTR_VTYPES
Definition: SUMOXMLDefinitions.h:632
GNEAttributeCarrier::~GNEAttributeCarrier
virtual ~GNEAttributeCarrier()
Destructor.
Definition: GNEAttributeCarrier.cpp:927
GNEAttributeCarrier::AttributeProperties::isBool
bool isBool() const
return true if atribute is boolean
Definition: GNEAttributeCarrier.cpp:370
TLTYPE_DELAYBASED
@ TLTYPE_DELAYBASED
Definition: SUMOXMLDefinitions.h:1202
GNEAttributeCarrier::fillLaneChangingModelAttributes
static void fillLaneChangingModelAttributes(SumoXMLTag currentTag)
fill Junction Model Attributes of Vehicle/Person Types
Definition: GNEAttributeCarrier.cpp:4273
SUMO_ATTR_EXPECTED_CONTAINERS
@ SUMO_ATTR_EXPECTED_CONTAINERS
Definition: SUMOXMLDefinitions.h:803
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition: SUMOXMLDefinitions.h:1407
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition: SUMOXMLDefinitions.h:598
GNEAttributeCarrier::FEATURE_MODIFIED
static const std::string FEATURE_MODIFIED
feature has been manually modified (implies approval)
Definition: GNEAttributeCarrier.h:598
GNEAttributeCarrier::AttributeProperties::hasAttrSynonym
bool hasAttrSynonym() const
return true if Attr correspond to an element that will be written in XML with another name
Definition: GNEAttributeCarrier.cpp:341
SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:790
GNEAttributeCarrier::TagProperties::canBlockMovement
bool canBlockMovement() const
return true if tag correspond to an element that can block their movement
Definition: GNEAttributeCarrier.cpp:804
SUMO_TAG_VAPORIZER
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
Definition: SUMOXMLDefinitions.h:218
SUMOXMLDefinitions::isValidVehicleID
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Definition: SUMOXMLDefinitions.cpp:973
SUMO_ATTR_K
@ SUMO_ATTR_K
Definition: SUMOXMLDefinitions.h:819
ICON_JUNCTION
@ ICON_JUNCTION
Definition: GUIIcons.h:258
SUMO_ATTR_CONTAINER_TRIGGERED
@ SUMO_ATTR_CONTAINER_TRIGGERED
Definition: SUMOXMLDefinitions.h:800
GNEAttributeCarrier::getAttribute
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEAttributeCarrier::AttributeProperties::isNumerical
bool isNumerical() const
return true if atribute is numerical (int or float)
Definition: GNEAttributeCarrier.cpp:394
ICON_WALK_FROMTO
@ ICON_WALK_FROMTO
Definition: GUIIcons.h:311
ICON_VARIABLESPEEDSIGN
@ ICON_VARIABLESPEEDSIGN
Definition: GUIIcons.h:281
SUMO_ATTR_VISIBLE
@ SUMO_ATTR_VISIBLE
Definition: SUMOXMLDefinitions.h:896
ICON_CLOSINGLANEREROUTE
@ ICON_CLOSINGLANEREROUTE
Definition: GUIIcons.h:288
GNEAttributeCarrier::TAGTYPE_RIDE
@ TAGTYPE_RIDE
Definition: GNEAttributeCarrier.h:289
SUMO_ATTR_EFFICIENCY
@ SUMO_ATTR_EFFICIENCY
Eficiency of the charge in Charging Stations.
Definition: SUMOXMLDefinitions.h:471
SUMO_ATTR_ONROAD
@ SUMO_ATTR_ONROAD
Definition: SUMOXMLDefinitions.h:773
SUMO_TAG_PERSONTRIP_FROMTO
@ SUMO_TAG_PERSONTRIP_FROMTO
Definition: SUMOXMLDefinitions.h:304
ICON_CLOSINGREROUTE
@ ICON_CLOSINGREROUTE
Definition: GUIIcons.h:287
SUMO_ATTR_CARRIAGE_LENGTH
@ SUMO_ATTR_CARRIAGE_LENGTH
Definition: SUMOXMLDefinitions.h:1014
SUMO_ATTR_ALLOW
@ SUMO_ATTR_ALLOW
Definition: SUMOXMLDefinitions.h:782
SUMO_TAG_RIDE_BUSSTOP
@ SUMO_TAG_RIDE_BUSSTOP
Definition: SUMOXMLDefinitions.h:311
ICON_ROUTE
@ ICON_ROUTE
Definition: GUIIcons.h:298
SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_POSITION_LAT
Definition: SUMOXMLDefinitions.h:661
SUMO_ATTR_RIGHT_OF_WAY
@ SUMO_ATTR_RIGHT_OF_WAY
How to compute right of way.
Definition: SUMOXMLDefinitions.h:698
SUMO_TAG_CONNECTION
@ SUMO_TAG_CONNECTION
connectio between two lanes
Definition: SUMOXMLDefinitions.h:202
GNEAttributeCarrier::TagProperties::isDrawable
bool isDrawable() const
return true if tag correspond to a drawable element
Definition: GNEAttributeCarrier.cpp:792
GNEAttributeCarrier::TagProperties::isDetector
bool isDetector() const
return true if tag correspond to a shape (Only used to group all detectors in the XML)
Definition: GNEAttributeCarrier.cpp:727
SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
Definition: SUMOXMLDefinitions.h:615
joinToString
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:246
GNEAttributeCarrier::ATTRPROPERTY_COLOR
@ ATTRPROPERTY_COLOR
Definition: GNEAttributeCarrier.h:73
SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_EMERGENCYDECEL
Definition: SUMOXMLDefinitions.h:447
GNEAttributeCarrier::TAGTYPE_STOPPINGPLACE
@ TAGTYPE_STOPPINGPLACE
Definition: GNEAttributeCarrier.h:279
SUMO_ATTR_UNCONTROLLED
@ SUMO_ATTR_UNCONTROLLED
Definition: SUMOXMLDefinitions.h:767
SUMO_ATTR_VCLASS
@ SUMO_ATTR_VCLASS
Definition: SUMOXMLDefinitions.h:450
GNEAttributeCarrier::TagProperties::hasDialog
bool hasDialog() const
return true if tag correspond to an element that can be edited using a dialog
Definition: GNEAttributeCarrier.cpp:846
SUMO_ATTR_MODES
@ SUMO_ATTR_MODES
Definition: SUMOXMLDefinitions.h:653
GNEAttributeCarrier::TAGTYPE_NETELEMENT
@ TAGTYPE_NETELEMENT
Definition: GNEAttributeCarrier.h:274
SUMO_TAG_ROUTEPROBE
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
Definition: SUMOXMLDefinitions.h:115
SUMO_TAG_WALK_BUSSTOP
@ SUMO_TAG_WALK_BUSSTOP
Definition: SUMOXMLDefinitions.h:308
GNENet::retrieveEdge
GNEEdge * retrieveEdge(const std::string &id, bool failHard=true)
get edge by id
Definition: GNENet.cpp:1069
GNEAttributeCarrier::FEATURE_APPROVED
static const std::string FEATURE_APPROVED
feature has been approved but not changed (i.e. after being reguessed)
Definition: GNEAttributeCarrier.h:601
GNEAttributeCarrier::TagProperties::getGUIIcon
GUIIcon getGUIIcon() const
get GUI icon associated to this Tag
Definition: GNEAttributeCarrier.cpp:654
SUMO_ATTR_PARKING
@ SUMO_ATTR_PARKING
Definition: SUMOXMLDefinitions.h:801
GNEAttributeCarrier::TagProperties::hasParameters
bool hasParameters() const
return true if Tag correspond to an element that supports parameters "key1=value1|key2=value2|....
Definition: GNEAttributeCarrier.cpp:858
SUMO_ATTR_JAM_DIST_THRESHOLD
@ SUMO_ATTR_JAM_DIST_THRESHOLD
Definition: SUMOXMLDefinitions.h:752
GNEAttributeCarrier.h
SUMO_TAG_ROUTE
@ SUMO_TAG_ROUTE
begin/end of the description of a route
Definition: SUMOXMLDefinitions.h:125
GNEAttributeCarrier::getAttributeForSelection
virtual std::string getAttributeForSelection(SumoXMLAttr key) const
method for getting the attribute in the context of object selection
Definition: GNEAttributeCarrier.cpp:1261
GNENet::retrieveLane
GNELane * retrieveLane(const std::string &id, bool failHard=true, bool checkVolatileChange=false)
get lane by id
Definition: GNENet.cpp:1228
Shape::DEFAULT_ANGLE
static const double DEFAULT_ANGLE
Definition: Shape.h:46
StringTokenizer::getVector
std::vector< std::string > getVector()
return vector of strings
Definition: StringTokenizer.cpp:191
SUMOXMLDefinitions::FringeTypeValues
static StringBijection< FringeType > FringeTypeValues
fringe types
Definition: SUMOXMLDefinitions.h:1380
GNEAttributeCarrier::AttributeProperties::getPositionListed
int getPositionListed() const
get position in list (used in frames for listing attributes with certain sort)
Definition: GNEAttributeCarrier.cpp:200
SUMO_TAG_E3DETECTOR
@ SUMO_TAG_E3DETECTOR
an e3 detector
Definition: SUMOXMLDefinitions.h:73
SUMO_ATTR_MINGAP
@ SUMO_ATTR_MINGAP
Definition: SUMOXMLDefinitions.h:458
GNEAttributeCarrier::TagProperties::getAttributeProperties
const AttributeProperties & getAttributeProperties(SumoXMLAttr attr) const
get attribute (throw error if doesn't exist)
Definition: GNEAttributeCarrier.cpp:623
GNEAttributeCarrier::getTagProperties
static const TagProperties & getTagProperties(SumoXMLTag tag)
get Tag Properties
Definition: GNEAttributeCarrier.cpp:1298
ICON_CALIBRATOR
@ ICON_CALIBRATOR
Definition: GUIIcons.h:282
SUMOXMLDefinitions::LaneSpreadFunctions
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
Definition: SUMOXMLDefinitions.h:1374
SUMO_TAG_PERSONFLOW
@ SUMO_TAG_PERSONFLOW
Definition: SUMOXMLDefinitions.h:299
SUMO_TAG_CLOSING_LANE_REROUTE
@ SUMO_TAG_CLOSING_LANE_REROUTE
lane of a reroute of type closing
Definition: SUMOXMLDefinitions.h:194
SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_ACTIONSTEPLENGTH
Definition: SUMOXMLDefinitions.h:449
StringTokenizer.h
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
GNEAttributeCarrier::ATTRPROPERTY_POSITIVE
@ ATTRPROPERTY_POSITIVE
Definition: GNEAttributeCarrier.h:75
GNEAttributeCarrier::TagProperties::canCloseShape
bool canCloseShape() const
return true if tag correspond to an element that can close their shape
Definition: GNEAttributeCarrier.cpp:816
GNEAttributeCarrier::TAGPROPERTY_SORTINGCHILDREN
@ TAGPROPERTY_SORTINGCHILDREN
Definition: GNEAttributeCarrier.h:312
GNEAttributeCarrier::AttributeProperties::isExtended
bool isExtended() const
return true if atribute is extended
Definition: GNEAttributeCarrier.cpp:466
SUMO_ATTR_LOCOMOTIVE_LENGTH
@ SUMO_ATTR_LOCOMOTIVE_LENGTH
Definition: SUMOXMLDefinitions.h:1015
SUMO_TAG_STOP_BUSSTOP
@ SUMO_TAG_STOP_BUSSTOP
stop placed over a busStop (used in netedit)
Definition: SUMOXMLDefinitions.h:182
PollutantsInterface::getAllClassesStr
static const std::vector< std::string > & getAllClassesStr()
Get all SUMOEmissionClass in string format.
Definition: PollutantsInterface.cpp:82
GNEAttributeCarrier::TagProperties::hasParent
bool hasParent() const
return true if tag correspond to an element that can had another element as parent
Definition: GNEAttributeCarrier.cpp:834
FRINGE_TYPE_DEFAULT
@ FRINGE_TYPE_DEFAULT
Definition: SUMOXMLDefinitions.h:1113
GNEAttributeCarrier::TAGPROPERTY_DRAWABLE
@ TAGPROPERTY_DRAWABLE
Definition: GNEAttributeCarrier.h:294
GNEAttributeCarrier::ATTRPROPERTY_BOOL
@ ATTRPROPERTY_BOOL
Definition: GNEAttributeCarrier.h:70
ICON_PERSONTRIP_FROMTO
@ ICON_PERSONTRIP_FROMTO
Definition: GUIIcons.h:308
SUMO_ATTR_FRINGE
@ SUMO_ATTR_FRINGE
Fringe type of node.
Definition: SUMOXMLDefinitions.h:700
GNEAttributeCarrier::AttributeProperties::isInt
bool isInt() const
return true if atribute is an integer
Definition: GNEAttributeCarrier.cpp:352
ICON_E3ENTRY
@ ICON_E3ENTRY
Definition: GUIIcons.h:275
GNEAttributeCarrier::AttributeProperties::getAttrSynonym
SumoXMLAttr getAttrSynonym() const
get tag synonym
Definition: GNEAttributeCarrier.cpp:299
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:433
SUMO_ATTR_TMP4
@ SUMO_ATTR_TMP4
Definition: SUMOXMLDefinitions.h:553
SUMOXMLDefinitions::LateralAlignments
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
Definition: SUMOXMLDefinitions.h:1401
SUMO_TAG_INTERVAL
@ SUMO_TAG_INTERVAL
an aggreagated-output interval
Definition: SUMOXMLDefinitions.h:159
GNEAttributeCarrier::TagProperties::isRide
bool isRide() const
return true if tag correspond to a ride element
Definition: GNEAttributeCarrier.cpp:780
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition: GNEAttributeCarrier.cpp:1267
SUMOXMLDefinitions::isValidListOfTypeID
static bool isValidListOfTypeID(const std::string &value)
whether the given string is a valid list of ids for an edge or vehicle type (empty aren't allowed)
Definition: SUMOXMLDefinitions.cpp:1024
SUMO_ATTR_NAME
@ SUMO_ATTR_NAME
Definition: SUMOXMLDefinitions.h:380
GNEAttributeCarrier::TAGPROPERTY_REPARENT
@ TAGPROPERTY_REPARENT
Definition: GNEAttributeCarrier.h:303
SUMO_TAG_PERSONSTOP_BUSSTOP
@ SUMO_TAG_PERSONSTOP_BUSSTOP
Definition: SUMOXMLDefinitions.h:312
GNEAttributeCarrier::AttributeProperties::hasAttrRange
bool hasAttrRange() const
return true if Attr correspond to an element that only accept a range of values
Definition: GNEAttributeCarrier.cpp:346
SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:786
GNEAttributeCarrier::AttributeProperties::isSVCPermission
bool isSVCPermission() const
return true if atribute is a VehicleClass
Definition: GNEAttributeCarrier.cpp:424
Shape::DEFAULT_IMG_FILE
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:47
GNEAttributeCarrier::isAttributeEnabled
virtual bool isAttributeEnabled(SumoXMLAttr key) const =0
ICON_VSSSTEP
@ ICON_VSSSTEP
Definition: GUIIcons.h:286
GNEAttributeCarrier::fillJunctionModelAttributes
static void fillJunctionModelAttributes(SumoXMLTag currentTag)
fill Junction Model Attributes of Vehicle/Person Types
Definition: GNEAttributeCarrier.cpp:4207
SUMO_TAG_ACCESS
@ SUMO_TAG_ACCESS
An access point for a train stop.
Definition: SUMOXMLDefinitions.h:103
GNEAttributeCarrier::TAGTYPE_WALK
@ TAGTYPE_WALK
Definition: GNEAttributeCarrier.h:288
GNEAttributeCarrier::FEATURE_LOADED
static const std::string FEATURE_LOADED
Definition: GNEAttributeCarrier.h:592
GNEAttributeCarrier::AttributeProperties::isString
bool isString() const
return true if atribute is a string
Definition: GNEAttributeCarrier.cpp:376
SUMO_TAG_CALIBRATOR
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
Definition: SUMOXMLDefinitions.h:91
SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_BUS_STOP
Definition: SUMOXMLDefinitions.h:769
GNEAttributeCarrier::AttributeProperties::isComplex
bool isComplex() const
return true if atribute is complex
Definition: GNEAttributeCarrier.cpp:484
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
SUMO_TAG_EMBEDDEDROUTE
@ SUMO_TAG_EMBEDDEDROUTE
begin/end of the description of a embedded route (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:127
GNE_ATTR_BIDIR
@ GNE_ATTR_BIDIR
whether an edge is part of a bidirectional railway
Definition: SUMOXMLDefinitions.h:979
SVC_IGNORING
@ SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:135
SUMO_TAG_E1DETECTOR
@ SUMO_TAG_E1DETECTOR
an e1 detector
Definition: SUMOXMLDefinitions.h:63
ICON_PERSON
@ ICON_PERSON
Definition: GUIIcons.h:306
SUMO_ATTR_NUMBER
@ SUMO_ATTR_NUMBER
Definition: SUMOXMLDefinitions.h:666
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMO_ATTR_ACTTYPE
@ SUMO_ATTR_ACTTYPE
Definition: SUMOXMLDefinitions.h:874
SUMO_ATTR_SHAPE
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:690
DEFAULT_VEH_PROB
const double DEFAULT_VEH_PROB
SUMO_ATTR_X
@ SUMO_ATTR_X
Definition: SUMOXMLDefinitions.h:398
SUMO_TAG_E2DETECTOR
@ SUMO_TAG_E2DETECTOR
an e2 detector
Definition: SUMOXMLDefinitions.h:67
SUMO_TAG_DET_EXIT
@ SUMO_TAG_DET_EXIT
an e3 exit point
Definition: SUMOXMLDefinitions.h:83
GNELane
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition: GNELane.h:45
SUMO_ATTR_ARRIVALLANE
@ SUMO_ATTR_ARRIVALLANE
Definition: SUMOXMLDefinitions.h:436
GNEAttributeCarrier::TAGTYPE_SHAPE
@ TAGTYPE_SHAPE
Definition: GNEAttributeCarrier.h:276
GNEAttributeCarrier::fillNetElements
static void fillNetElements()
fill Net Elements
Definition: GNEAttributeCarrier.cpp:1478
GNEAttributeCarrier::fillCommonPersonAttributes
static void fillCommonPersonAttributes(SumoXMLTag currentTag)
fill common person attributes (used by person and personFlows)
Definition: GNEAttributeCarrier.cpp:4396
SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_EMISSIONCLASS
Definition: SUMOXMLDefinitions.h:795
Shape::DEFAULT_LAYER_POI
static const double DEFAULT_LAYER_POI
Definition: Shape.h:45
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:284
ICON_ROUTEPROBREROUTE
@ ICON_ROUTEPROBREROUTE
Definition: GUIIcons.h:291
SUMO_TAG_RIDE_FROMTO
@ SUMO_TAG_RIDE_FROMTO
Definition: SUMOXMLDefinitions.h:310
ICON_WALK_ROUTE
@ ICON_WALK_ROUTE
Definition: GUIIcons.h:313
GNENet.h
SUMO_TAG_TRIP
@ SUMO_TAG_TRIP
a single trip definition (used by router)
Definition: SUMOXMLDefinitions.h:145
SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_LCA_PUSHY
Definition: SUMOXMLDefinitions.h:594
SUMOXMLDefinitions::NodeTypes
static StringBijection< SumoXMLNodeType > NodeTypes
node types
Definition: SUMOXMLDefinitions.h:1368
GNEAttributeCarrier::TagProperties::canMaskXYZPositions
bool canMaskXYZPositions() const
return true if tag correspond to an element that can mask the attributes "X", "Y" and "Z" position as...
Definition: GNEAttributeCarrier.cpp:901
GNEAttributeCarrier::TAGPROPERTY_CLOSESHAPE
@ TAGPROPERTY_CLOSESHAPE
Definition: GNEAttributeCarrier.h:297
GNEAttributeCarrier::MAXNUMBEROFATTRIBUTES
static const size_t MAXNUMBEROFATTRIBUTES
max number of attributes allowed for every tag
Definition: GNEAttributeCarrier.h:605
ICON_CONTAINERSTOP
@ ICON_CONTAINERSTOP
Definition: GUIIcons.h:270
SUMO_TAG_INSTANT_INDUCTION_LOOP
@ SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
Definition: SUMOXMLDefinitions.h:87
ICON_RIDE_BUSSTOP
@ ICON_RIDE_BUSSTOP
Definition: GUIIcons.h:315
GNEAttributeCarrier::TagProperties::getNumberOfAttributes
int getNumberOfAttributes() const
get number of attributes
Definition: GNEAttributeCarrier.cpp:648
SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_CF_KERNER_PHI
Definition: SUMOXMLDefinitions.h:840
GNEAttributeCarrier::AttributeProperties::getDescription
std::string getDescription() const
return a description of attribute
Definition: GNEAttributeCarrier.cpp:223
SUMO_TAG_JUNCTION
@ SUMO_TAG_JUNCTION
begin/end of the description of a junction
Definition: SUMOXMLDefinitions.h:59
ICON_REROUTERINTERVAL
@ ICON_REROUTERINTERVAL
Definition: GUIIcons.h:285
TLTYPE_ACTUATED
@ TLTYPE_ACTUATED
Definition: SUMOXMLDefinitions.h:1201
SUMO_ATTR_CONTPOS
@ SUMO_ATTR_CONTPOS
Definition: SUMOXMLDefinitions.h:749
SUMO_ATTR_TAU
@ SUMO_ATTR_TAU
Definition: SUMOXMLDefinitions.h:549
GNEAttributeCarrier::AttributeProperties::setRange
void setRange(const double minimum, const double maximum)
set range
Definition: GNEAttributeCarrier.cpp:157
SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition: SUMOXMLDefinitions.h:839
SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_ACCEL_LAT
Definition: SUMOXMLDefinitions.h:599
Shape::DEFAULT_IMG_WIDTH
static const double DEFAULT_IMG_WIDTH
Definition: Shape.h:49
NODETYPE_NOJUNCTION
@ NODETYPE_NOJUNCTION
Definition: SUMOXMLDefinitions.h:1067
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition: SUMOXMLDefinitions.h:604
ICON_REROUTER
@ ICON_REROUTER
Definition: GUIIcons.h:278
GeomConvHelper::parseShapeReporting
static PositionVector parseShapeReporting(const std::string &shpdef, const std::string &objecttype, const char *objectid, bool &ok, bool allowEmpty, bool report=true)
Builds a PositionVector from a string representation, reporting occurred errors.
Definition: GeomConvHelper.cpp:38
GNEAttributeCarrier::TAGTYPE_PERSON
@ TAGTYPE_PERSON
Definition: GNEAttributeCarrier.h:285