Tapkee
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
parameters.hpp
Go to the documentation of this file.
1 /* This software is distributed under BSD 3-clause license (see LICENSE file).
2  *
3  * Copyright (c) 2012-2013 Sergey Lisitsyn
4  */
5 
6 #ifndef TAPKEE_PARAMETERS_H_
7 #define TAPKEE_PARAMETERS_H_
8 
9 /* Tapkee includes */
11 /* End of Tapkee includes */
12 
13 #include <sstream>
14 #include <vector>
15 #include <map>
16 
17 namespace tapkee
18 {
19 
20 struct Message
21 {
22  Message() : ss()
23  {
24  }
25  template <typename T>
26  Message& operator<<(const T& data)
27  {
28  ss << data;
29  return *this;
30  }
31  operator std::string()
32  {
33  return ss.str();
34  }
35 
36  std::stringstream ss;
37 };
38 
39 class ParametersSet;
40 class CheckedParameter;
41 
42 class Parameter
43 {
44  friend class CheckedParameter;
45 
46  typedef std::string ParameterName;
47 
48 private:
49 
50  template <typename T>
51  Parameter(const ParameterName& pname, const T& value) :
52  valid(true), invalidity_reason(),
53  parameter_name(pname), keeper(tapkee_internal::ValueKeeper(value))
54  {
55  }
56 
57 public:
58 
59  template <typename T>
60  static Parameter create(const std::string& name, const T& value)
61  {
62  return Parameter(name, value);
63  }
64 
65  Parameter() :
66  valid(false), invalidity_reason(),
67  parameter_name("unknown"), keeper(tapkee_internal::ValueKeeper())
68  {
69  }
70 
71  Parameter(const Parameter& p) :
74  {
75  }
76 
78  {
79  }
80 
81  template <typename T>
82  inline Parameter withDefault(T value)
83  {
84  if (!isInitialized())
85  {
87  }
88  return *this;
89  }
90 
91  template <typename T>
92  inline operator T()
93  {
94  if (!valid)
95  {
97  }
98  try
99  {
100  return getValue<T>();
101  }
102  catch (const missed_parameter_error&)
103  {
104  throw missed_parameter_error(parameter_name + " is missed");
105  }
106  }
107 
108  operator ParametersSet();
109 
110  template <typename T>
111  bool is(T v)
112  {
113  if (!isTypeCorrect<T>())
114  return false;
115  T kv = keeper.getValue<T>();
116  if (v == kv)
117  return true;
118  return false;
119  }
120 
121  template <typename T>
122  bool operator==(T v) const
123  {
124  return is<T>(v);
125  }
126 
128 
129  template <typename T>
130  bool isInRange(T lower, T upper) const
131  {
132  return keeper.inRange<T>(lower, upper);
133  }
134 
135  template <typename T>
136  bool isEqual(T value) const
137  {
138  return keeper.equal<T>(value);
139  }
140 
141  template <typename T>
142  bool isNotEqual(T value) const
143  {
144  return keeper.notEqual<T>(value);
145  }
146 
147  bool isPositive() const
148  {
149  return keeper.positive();
150  }
151 
152  bool isNonNegative() const
153  {
154  return keeper.nonNegative();
155  }
156 
157  bool isNegative() const
158  {
159  return keeper.negative();
160  }
161 
162  template <typename T>
163  bool isGreater(T lower) const
164  {
165  return keeper.greater<T>(lower);
166  }
167 
168  template <typename T>
169  bool isLesser(T upper) const
170  {
171  return keeper.lesser<T>(upper);
172  }
173 
174  bool isInitialized() const
175  {
176  return keeper.isInitialized();
177  }
178 
180  {
181  return parameter_name;
182  }
183 
185 
186 private:
187 
188  template <typename T>
189  inline T getValue() const
190  {
191  return keeper.getValue<T>();
192  }
193 
194  template <typename T>
195  inline bool isTypeCorrect() const
196  {
197  return keeper.isTypeCorrect<T>();
198  }
199 
200  inline void invalidate(const std::string& reason)
201  {
202  valid = false;
203  invalidity_reason = reason;
204  }
205 
206 private:
207 
208  bool valid;
209  std::string invalidity_reason;
210 
212 
214 
215 };
216 
218 {
219 
220 public:
221 
223  {
224  }
225 
226  inline operator const Parameter&()
227  {
228  return parameter;
229  }
230 
231  template <typename T>
232  bool is(T v)
233  {
234  return parameter.is<T>(v);
235  }
236 
237  template <typename T>
238  bool operator==(T v)
239  {
240  return is<T>(v);
241  }
242 
243  template <typename T>
244  CheckedParameter& inRange(T lower, T upper)
245  {
246  if (!parameter.isInRange(lower, upper))
247  {
248  std::string reason =
249  (Message() << "Value of " << parameter.name() << " "
250  << parameter.getValue<T>() << " doesn't fit the range [" <<
251  lower << ", " << upper << ")");
252  parameter.invalidate(reason);
253  }
254  return *this;
255  }
256 
257  template <typename T>
258  CheckedParameter& inClosedRange(T lower, T upper)
259  {
260  if (!parameter.isInRange(lower, upper) && !parameter.is(upper))
261  {
262  std::string reason =
263  (Message() << "Value of " << parameter.name() << " "
264  << parameter.getValue<T>() << " doesn't fit the range [" <<
265  lower << ", " << upper << "]");
266  parameter.invalidate(reason);
267  }
268  return *this;
269  }
270 
272  {
273  if (!parameter.isPositive())
274  {
275  std::string reason =
276  (Message() << "Value of " << parameter.name() << " is not positive");
277  parameter.invalidate(reason);
278  }
279  return *this;
280  }
281 
283  {
284  if (!parameter.isNonNegative())
285  {
286  std::string reason =
287  (Message() << "Value of " << parameter.name() << " is negative");
288  parameter.invalidate(reason);
289  }
290  return *this;
291  }
292 
293 
294 private:
295 
297 
298 };
299 
301 {
302  return CheckedParameter(*this);
303 }
304 
306 {
307 public:
308 
309  typedef std::map<std::string, Parameter> ParametersMap;
310 
312  {
313  }
314  void add(const Parameter& p)
315  {
316  if (pmap.count(p.name()))
317  throw multiple_parameter_error(Message() << "Parameter " << p.name() << " is set more than once");
318 
319  pmap[p.name()] = p;
320  }
321  bool contains(const std::string& name) const
322  {
323  return pmap.count(name) > 0;
324  }
325  void merge(const ParametersSet& pg)
326  {
327  typedef ParametersMap::const_iterator MapIter;
328  for (MapIter iter = pg.pmap.begin(); iter!=pg.pmap.end(); ++iter)
329  {
330  if (!pmap.count(iter->first))
331  {
332  pmap[iter->first] = iter->second;
333  }
334  }
335  }
336  Parameter operator()(const std::string& name) const
337  {
338  ParametersMap::const_iterator it = pmap.find(name);
339  if (it != pmap.end())
340  {
341  return it->second;
342  }
343  else
344  {
345  throw missed_parameter_error(Message() << "Parameter " << name << " is missed");
346  }
347  }
349  {
350  add(p);
351  return *this;
352  }
353 
354 private:
355 
357 };
358 
360 {
361  ParametersSet pg;
362  pg.add(*this);
363  pg.add(p);
364  return pg;
365 }
366 
367 Parameter::operator ParametersSet()
368 {
369  ParametersSet pg;
370  pg.add(*this);
371  return pg;
372 }
373 
374 
375 }
376 
377 #endif
CheckedParameter(Parameter &p)
Definition: parameters.hpp:222
An exception type that is thrown in case if wrong parameter value is passed.
Definition: exceptions.hpp:17
bool contains(const std::string &name) const
Definition: parameters.hpp:321
CheckedParameter & positive()
Definition: parameters.hpp:271
std::stringstream ss
Definition: parameters.hpp:36
ParametersMap pmap
Definition: parameters.hpp:356
static Parameter create(const std::string &name, const T &value)
Definition: parameters.hpp:60
tapkee_internal::ValueKeeper keeper
Definition: parameters.hpp:213
Parameter(const Parameter &p)
Definition: parameters.hpp:71
std::map< std::string, Parameter > ParametersMap
Definition: parameters.hpp:309
An exception type that is thrown in case of missed parameter, i.e. when some required parameter is no...
Definition: exceptions.hpp:37
CheckedParameter checked()
Definition: parameters.hpp:300
bool isEqual(T value) const
Definition: parameters.hpp:136
void merge(const ParametersSet &pg)
Definition: parameters.hpp:325
ParametersSet operator,(const Parameter &p)
Definition: parameters.hpp:359
T getValue() const
Definition: parameters.hpp:189
Parameter operator()(const std::string &name) const
Definition: parameters.hpp:336
Parameter(const ParameterName &pname, const T &value)
Definition: parameters.hpp:51
ParameterName parameter_name
Definition: parameters.hpp:211
bool isNegative() const
Definition: parameters.hpp:157
void invalidate(const std::string &reason)
Definition: parameters.hpp:200
An exception type that is thrown when some parameter is passed more than once.
Definition: exceptions.hpp:66
ParametersSet & operator,(const Parameter &p)
Definition: parameters.hpp:348
bool isNonNegative() const
Definition: parameters.hpp:152
bool isLesser(T upper) const
Definition: parameters.hpp:169
void add(const Parameter &p)
Definition: parameters.hpp:314
bool operator==(T v) const
Definition: parameters.hpp:122
bool isInRange(T lower, T upper) const
Definition: parameters.hpp:130
bool isPositive() const
Definition: parameters.hpp:147
bool isInitialized() const
Definition: parameters.hpp:174
std::string invalidity_reason
Definition: parameters.hpp:209
bool isNotEqual(T value) const
Definition: parameters.hpp:142
Message & operator<<(const T &data)
Definition: parameters.hpp:26
CheckedParameter & inRange(T lower, T upper)
Definition: parameters.hpp:244
CheckedParameter & nonNegative()
Definition: parameters.hpp:282
std::string ParameterName
Definition: parameters.hpp:46
bool isGreater(T lower) const
Definition: parameters.hpp:163
bool inRange(T lower, T upper) const
Parameter withDefault(T value)
Definition: parameters.hpp:82
ParameterName name() const
Definition: parameters.hpp:179
bool isTypeCorrect() const
Definition: parameters.hpp:195
CheckedParameter & inClosedRange(T lower, T upper)
Definition: parameters.hpp:258
friend class CheckedParameter
Definition: parameters.hpp:44