Eclipse SUMO - Simulation of Urban MObility
Parameterised.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 // A super class for objects with additional parameters
15 /****************************************************************************/
16 
17 
18 // ===========================================================================
19 // included modules
20 // ===========================================================================
21 
22 #include <config.h>
27 
28 #include "Parameterised.h"
29 
30 
31 // ===========================================================================
32 // method definitions
33 // ===========================================================================
35 
36 
38 
39 
40 Parameterised::Parameterised(const std::map<std::string, std::string>& mapArg)
41  : myMap(mapArg) {
42 }
43 
44 
45 void
46 Parameterised::setParameter(const std::string& key, const std::string& value) {
47  myMap[key] = value;
48 }
49 
50 
51 void
52 Parameterised::unsetParameter(const std::string& key) {
53  myMap.erase(key);
54 }
55 
56 
57 void
58 Parameterised::updateParameters(const std::map<std::string, std::string>& mapArg) {
59  for (auto i : mapArg) {
60  myMap[i.first] = i.second;
61  }
62 }
63 
64 
65 bool
66 Parameterised::knowsParameter(const std::string& key) const {
67  return myMap.find(key) != myMap.end();
68 }
69 
70 
71 const std::string
72 Parameterised::getParameter(const std::string& key, const std::string& defaultValue) const {
73  std::map<std::string, std::string>::const_iterator i = myMap.find(key);
74  if (i != myMap.end()) {
75  return i->second;
76  }
77  return defaultValue;
78 }
79 
80 
81 double
82 Parameterised::getDouble(const std::string& key, const double defaultValue) const {
83  std::map<std::string, std::string>::const_iterator i = myMap.find(key);
84  if (i != myMap.end()) {
85  try {
86  return StringUtils::toDouble(i->second);
87  } catch (NumberFormatException&) {
88  WRITE_WARNING("Invalid conversion from string to double (" + i->second + ")");
89  return defaultValue;
90  } catch (EmptyData&) {
91  WRITE_WARNING("Invalid conversion from string to double (empty value)");
92  return defaultValue;
93  }
94  }
95  return defaultValue;
96 }
97 
98 
99 void
101  myMap.clear();
102 }
103 
104 
105 const std::map<std::string, std::string>&
107  return myMap;
108 }
109 
110 
111 std::string
113  std::string result;
114  // Generate an string using the following structure: "key1=value1|key2=value2|...|keyN=valueN"
115  for (const auto& i : myMap) {
116  result += i.first + "=" + i.second + "|";
117  }
118  // remove the last "|"
119  if (!result.empty()) {
120  result.pop_back();
121  }
122  return result;
123 }
124 
125 
126 void
128  myMap = params.getParametersMap();
129 }
130 
131 
132 void
133 Parameterised::setParametersMap(const std::map<std::string, std::string>& paramsMap) {
134  myMap = paramsMap;
135 }
136 
137 
138 void
139 Parameterised::setParametersStr(const std::string& paramsString) {
140  // clear parameters
141  myMap.clear();
142  // separate value in a vector of string using | as separator
143  std::vector<std::string> parameters = StringTokenizer(paramsString, "|", true).getVector();
144  // iterate over all values
145  for (const auto& i : parameters) {
146  // obtain key and value and save it in myParameters
147  std::vector<std::string> keyValue = StringTokenizer(i, "=", true).getVector();
148  myMap[keyValue.front()] = keyValue.back();
149  }
150 }
151 
152 
153 void
155  // iterate over all parameters and write it
156  for (auto i : myMap) {
157  device.openTag(SUMO_TAG_PARAM);
160  device.closeTag();
161  }
162 }
163 
164 
165 bool
166 Parameterised::areParametersValid(const std::string& value, bool report) {
167  // obtain vector of strings using '|' as delimiter
168  std::vector<std::string> parameters = StringTokenizer(value, "|", true).getVector();
169  // first check if parsed parameters are valid
170  for (const auto& i : parameters) {
171  // check if parameter is valid
172  if (!isParameterValid(i, report)) {
173  // report depending of flag
174  if (report) {
175  WRITE_WARNING("Invalid format of parameter (" + i + ")");
176  }
177  return false;
178  }
179  }
180  // all ok, then return true
181  return true;
182 }
183 
184 // ===========================================================================
185 // private
186 // ===========================================================================
187 
188 bool
189 Parameterised::isParameterValid(const std::string& value, bool /* report */) {
190  // first check if value has the character "|"
191  if (std::find(value.begin(), value.end(), '|') != value.end()) {
192  return false;
193  }
194  // now check if value has the character "="
195  if (std::find(value.begin(), value.end(), '=') == value.end()) {
196  return false;
197  }
198  // separate key and value
199  std::vector<std::string> keyValue = StringTokenizer(value, "=", true).getVector();
200  // Check that keyValue size is exactly 2 (key, value)
201  if (keyValue.size() == 2) {
202  // check if key and value contains valid characters
203  if (SUMOXMLDefinitions::isValidParameterKey(keyValue.front()) == false) {
204  return false;
205  } else if (SUMOXMLDefinitions::isValidParameterValue(keyValue.back()) == false) {
206  return false;
207  } else {
208  // key=value valid, then return true
209  return true;
210  }
211  } else {
212  // invalid format
213  return false;
214  }
215 }
216 
217 /****************************************************************************/
218 
Parameterised::isParameterValid
static bool isParameterValid(const std::string &value, bool report)
check if given string can be parsed to a parameter of type "key=value"
Definition: Parameterised.cpp:189
Parameterised::getParametersStr
std::string getParametersStr() const
Returns the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN".
Definition: Parameterised.cpp:112
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
Parameterised
An upper class for objects with additional parameters.
Definition: Parameterised.h:42
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
SUMO_TAG_PARAM
@ SUMO_TAG_PARAM
parameter associated to a certain key
Definition: SUMOXMLDefinitions.h:169
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
MsgHandler.h
EmptyData
Definition: UtilExceptions.h:68
Parameterised::Parameterised
Parameterised()
Constructor.
Definition: Parameterised.cpp:34
Parameterised::setParameters
void setParameters(const Parameterised &params)
set the inner key/value map in map<string, string> format
Definition: Parameterised.cpp:127
Parameterised::setParametersMap
void setParametersMap(const std::map< std::string, std::string > &paramsMap)
set the inner key/value map in map<string, string> format
Definition: Parameterised.cpp:133
Parameterised::writeParams
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
Definition: Parameterised.cpp:154
Parameterised::getParameter
const std::string getParameter(const std::string &key, const std::string &defaultValue="") const
Returns the value for a given key.
Definition: Parameterised.cpp:72
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:253
NumberFormatException
Definition: UtilExceptions.h:95
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:255
Parameterised::getParametersMap
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
Definition: Parameterised.cpp:106
SUMOXMLDefinitions::isValidParameterKey
static bool isValidParameterKey(const std::string &value)
whether the given string is a valid key for a parameter
Definition: SUMOXMLDefinitions.cpp:1041
Parameterised::updateParameters
void updateParameters(const std::map< std::string, std::string > &mapArg)
Adds or updates all given parameters from the map.
Definition: Parameterised.cpp:58
Parameterised.h
StringTokenizer
Definition: StringTokenizer.h:61
StringUtils::escapeXML
static std::string escapeXML(const std::string &orig, const bool maskDoubleHyphen=false)
Replaces the standard escapes by their XML entities.
Definition: StringUtils.cpp:190
OutputDevice.h
SUMOXMLDefinitions::isValidParameterValue
static bool isValidParameterValue(const std::string &value)
whether the given string is a valid value for a parameter
Definition: SUMOXMLDefinitions.cpp:1052
Parameterised::~Parameterised
~Parameterised()
Destructor.
Definition: Parameterised.cpp:37
Parameterised::setParametersStr
void setParametersStr(const std::string &paramsString)
set the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN"
Definition: Parameterised.cpp:139
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition: OutputDevice.cpp:239
StringUtils.h
Parameterised::areParametersValid
static bool areParametersValid(const std::string &value, bool report=false)
check if given string can be parsed to a parameters map "key1=value1|key2=value2|....
Definition: Parameterised.cpp:166
Parameterised::unsetParameter
void unsetParameter(const std::string &key)
Removes a parameter.
Definition: Parameterised.cpp:52
SUMO_ATTR_KEY
@ SUMO_ATTR_KEY
Definition: SUMOXMLDefinitions.h:408
SUMO_ATTR_VALUE
@ SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:779
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:46
Parameterised::clearParameter
void clearParameter()
Clears the parameter map.
Definition: Parameterised.cpp:100
StringTokenizer::getVector
std::vector< std::string > getVector()
return vector of strings
Definition: StringTokenizer.cpp:191
config.h
StringTokenizer.h
Parameterised::myMap
std::map< std::string, std::string > myMap
The key->value map.
Definition: Parameterised.h:120
Parameterised::getDouble
double getDouble(const std::string &key, const double defaultValue) const
Returns the value for a given key converted to a double.
Definition: Parameterised.cpp:82
Parameterised::knowsParameter
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
Definition: Parameterised.cpp:66