LCOV - code coverage report
Current view: top level - parameters - parameters.hpp (source / functions) Hit Total Coverage
Test: clean.info Lines: 100 108 92.6 %
Date: 2013-05-24 Functions: 74 79 93.7 %
Branches: 100 328 30.5 %

           Branch data     Line data    Source code
       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 */
      10                 :            : #include <tapkee/parameters/value_keeper.hpp>
      11                 :            : /* End of Tapkee includes */
      12                 :            : 
      13                 :            : #include <sstream>
      14                 :            : #include <vector>
      15                 :            : #include <map>
      16                 :            : 
      17                 :            : namespace tapkee
      18                 :            : {
      19                 :            : 
      20                 :          5 : struct Message
      21                 :            : {
      22                 :          5 :         Message() : ss()
      23                 :            :         {
      24                 :          5 :         }
      25                 :            :         template <typename T>
      26                 :         27 :         Message& operator<<(const T& data)
      27                 :            :         {
      28                 :         27 :                 ss << data;
      29                 :         27 :                 return *this;
      30                 :            :         }
      31                 :          5 :         operator std::string() 
      32                 :            :         {
      33                 :          5 :                 return ss.str();
      34                 :            :         }
      35                 :            : 
      36                 :            :         std::stringstream ss;
      37                 :            : };
      38                 :            : 
      39                 :            : class ParametersSet;
      40                 :            : class CheckedParameter;
      41                 :            : 
      42                 :       1626 : class Parameter
      43                 :            : {
      44                 :            :         friend class CheckedParameter;
      45                 :            : 
      46                 :            :         typedef std::string ParameterName;
      47                 :            : 
      48                 :            : private:
      49                 :            : 
      50                 :            :         template <typename T>
      51                 :        204 :         Parameter(const ParameterName& pname, const T& value) : 
      52                 :            :                 valid(true), invalidity_reason(),
      53 [ +  - ][ +  - ]:        204 :                 parameter_name(pname), keeper(tapkee_internal::ValueKeeper(value))
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
      54                 :            :         {
      55                 :        204 :         }
      56                 :            : 
      57                 :            : public:
      58                 :            : 
      59                 :            :         template <typename T>
      60                 :        204 :         static Parameter create(const std::string& name, const T& value) 
      61                 :            :         {
      62                 :        204 :                 return Parameter(name, value);
      63                 :            :         }
      64                 :            : 
      65                 :       1626 :         Parameter() : 
      66                 :            :                 valid(false), invalidity_reason(),
      67 [ +  - ][ +  - ]:       1626 :                 parameter_name("unknown"), keeper(tapkee_internal::ValueKeeper())
      68                 :            :         {
      69                 :       1626 :         }
      70                 :            : 
      71                 :       3734 :         Parameter(const Parameter& p) : 
      72                 :            :                 valid(p.valid), invalidity_reason(p.invalidity_reason),
      73 [ +  - ][ +  - ]:       3734 :                 parameter_name(p.name()), keeper(p.keeper)
      74                 :            :         {
      75                 :       3734 :         }
      76                 :            : 
      77                 :       5564 :         ~Parameter()
      78 [ +  - ][ +  - ]:       5564 :         {
      79                 :       5564 :         }
      80                 :            : 
      81                 :            :         template <typename T>
      82                 :            :         inline Parameter withDefault(T value)
      83                 :            :         {
      84                 :            :                 if (!isInitialized())
      85                 :            :                 {
      86                 :            :                         keeper = tapkee_internal::ValueKeeper(value);
      87                 :            :                 }
      88                 :            :                 return *this;
      89                 :            :         }
      90                 :            : 
      91                 :            :         template <typename T>
      92                 :        285 :         inline operator T()
      93                 :            :         {
      94 [ -  + ][ -  + ]:        285 :                 if (!valid)
         [ -  + ][ -  + ]
         [ -  + ][ -  + ]
         [ -  + ][ +  + ]
      95                 :            :                 {
      96 [ #  # ][ #  # ]:          1 :                         throw wrong_parameter_error(invalidity_reason);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ +  - ]
      97                 :            :                 }
      98                 :            :                 try 
      99                 :            :                 {
     100 [ +  - ][ +  - ]:        284 :                         return getValue<T>();
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     101                 :            :                 }
     102 [ #  # ][ #  # ]:          0 :                 catch (const missed_parameter_error&)
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     103                 :            :                 {
     104 [ #  # ][ #  # ]:          0 :                         throw missed_parameter_error(parameter_name + " is missed");
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     105                 :            :                 }
     106                 :            :         }
     107                 :            : 
     108                 :            :         operator ParametersSet();
     109                 :            : 
     110                 :            :         template <typename T>
     111                 :          2 :         bool is(T v)
     112                 :            :         {
     113 [ #  # ][ -  + ]:          2 :                 if (!isTypeCorrect<T>())
                 [ -  + ]
     114                 :          0 :                         return false;
     115                 :          2 :                 T kv = keeper.getValue<T>();
     116   [ #  #  -  +  :          2 :                 if (v == kv)
                   -  + ]
     117                 :          0 :                         return true;
     118                 :          2 :                 return false;
     119                 :            :         }
     120                 :            : 
     121                 :            :         template <typename T>
     122                 :            :         bool operator==(T v) const
     123                 :            :         {
     124                 :            :                 return is<T>(v);
     125                 :            :         }
     126                 :            : 
     127                 :            :         CheckedParameter checked();
     128                 :            : 
     129                 :            :         template <typename T>
     130                 :         77 :         bool isInRange(T lower, T upper) const
     131                 :            :         {
     132                 :         77 :                 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                 :        195 :         bool isPositive() const 
     148                 :            :         {
     149                 :        195 :                 return keeper.positive();
     150                 :            :         }
     151                 :            :         
     152                 :        117 :         bool isNonNegative() const 
     153                 :            :         {
     154                 :        117 :                 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                 :            : 
     179                 :       4143 :         ParameterName name() const 
     180                 :            :         {
     181                 :       4143 :                 return parameter_name;
     182                 :            :         }
     183                 :            : 
     184                 :            :         ParametersSet operator,(const Parameter& p);
     185                 :            : 
     186                 :            : private:
     187                 :            : 
     188                 :            :         template <typename T>
     189                 :        286 :         inline T getValue() const
     190                 :            :         {
     191                 :        286 :                 return keeper.getValue<T>();
     192                 :            :         }
     193                 :            :         
     194                 :            :         template <typename T>
     195                 :          2 :         inline bool isTypeCorrect() const
     196                 :            :         {
     197                 :          2 :                 return keeper.isTypeCorrect<T>();
     198                 :            :         }
     199                 :            : 
     200                 :          3 :         inline void invalidate(const std::string& reason)
     201                 :            :         {
     202                 :          3 :                 valid = false;
     203                 :          3 :                 invalidity_reason = reason;
     204                 :          3 :         }
     205                 :            : 
     206                 :            : private:
     207                 :            : 
     208                 :            :         bool valid;
     209                 :            :         std::string invalidity_reason;
     210                 :            : 
     211                 :            :         ParameterName parameter_name;
     212                 :            : 
     213                 :            :         tapkee_internal::ValueKeeper keeper; 
     214                 :            : 
     215                 :            : };
     216                 :            : 
     217                 :            : class CheckedParameter
     218                 :            : {
     219                 :            : 
     220                 :            : public:
     221                 :            : 
     222                 :        389 :         explicit CheckedParameter(Parameter& p) : parameter(p)
     223                 :            :         {
     224                 :        389 :         }
     225                 :            : 
     226                 :        312 :         inline operator const Parameter&()
     227                 :            :         {
     228                 :        312 :                 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                 :         74 :         CheckedParameter& inRange(T lower, T upper)
     245                 :            :         {
     246 [ #  # ][ +  + ]:         74 :                 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 [ #  # ][ #  # ]:          2 :                                     lower << ", " << upper << ")");
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     252 [ #  # ][ +  - ]:          2 :                         parameter.invalidate(reason);
     253                 :            :                 }
     254                 :         74 :                 return *this;
     255                 :            :         }
     256                 :            : 
     257                 :            :         template <typename T>
     258                 :          3 :         CheckedParameter& inClosedRange(T lower, T upper)
     259                 :            :         {
     260 [ -  + ][ #  # ]:          3 :                 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 [ #  # ][ #  # ]:          0 :                                     lower << ", " << upper << "]");
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     266         [ #  # ]:          0 :                         parameter.invalidate(reason);
     267                 :            :                 }
     268                 :          3 :                 return *this;
     269                 :            :         }
     270                 :            : 
     271                 :        195 :         CheckedParameter& positive()
     272                 :            :         {
     273         [ +  + ]:        195 :                 if (!parameter.isPositive())
     274                 :            :                 {
     275                 :            :                         std::string reason = 
     276 [ +  - ][ +  - ]:          1 :                                 (Message() << "Value of " << parameter.name() << " is not positive");
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
                 [ +  - ]
     277         [ +  - ]:          1 :                         parameter.invalidate(reason);
     278                 :            :                 }
     279                 :        195 :                 return *this;
     280                 :            :         }
     281                 :            : 
     282                 :        117 :         CheckedParameter& nonNegative()
     283                 :            :         {
     284         [ -  + ]:        117 :                 if (!parameter.isNonNegative())
     285                 :            :                 {
     286                 :            :                         std::string reason = 
     287 [ #  # ][ #  # ]:          0 :                                 (Message() << "Value of " << parameter.name() << " is negative");
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     288         [ #  # ]:          0 :                         parameter.invalidate(reason);
     289                 :            :                 }
     290                 :        117 :                 return *this;
     291                 :            :         }
     292                 :            : 
     293                 :            : 
     294                 :            : private:
     295                 :            : 
     296                 :            :         Parameter& parameter;
     297                 :            : 
     298                 :            : };
     299                 :            : 
     300                 :        389 : CheckedParameter Parameter::checked() 
     301                 :            : {
     302                 :        389 :         return CheckedParameter(*this);
     303                 :            : }
     304                 :            : 
     305                 :        319 : class ParametersSet
     306                 :            : {
     307                 :            : public:
     308                 :            : 
     309                 :            :         typedef std::map<std::string, Parameter> ParametersMap;
     310                 :            : 
     311                 :         47 :         ParametersSet() : pmap() 
     312                 :            :         {
     313                 :         47 :         }
     314                 :        203 :         void add(const Parameter& p) 
     315                 :            :         {
     316 [ +  - ][ +  + ]:        203 :                 if (pmap.count(p.name()))
     317 [ +  - ][ +  - ]:          1 :                         throw multiple_parameter_error(Message() << "Parameter " << p.name() << " is set more than once");
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
                 [ +  - ]
     318                 :            : 
     319 [ +  - ][ +  - ]:        202 :                 pmap[p.name()] = p;
     320                 :        202 :         }
     321                 :            :         bool contains(const std::string& name) const
     322                 :            :         {
     323                 :            :                 return pmap.count(name) > 0;
     324                 :            :         }
     325                 :         40 :         void merge(const ParametersSet& pg) 
     326                 :            :         {
     327                 :            :                 typedef ParametersMap::const_iterator MapIter;
     328         [ +  + ]:        840 :                 for (MapIter iter = pg.pmap.begin(); iter!=pg.pmap.end(); ++iter)
     329                 :            :                 {
     330         [ +  + ]:        800 :                         if (!pmap.count(iter->first))
     331                 :            :                         {
     332                 :        722 :                                 pmap[iter->first] = iter->second;
     333                 :            :                         }
     334                 :            :                 }
     335                 :         40 :         }
     336                 :        823 :         Parameter operator()(const std::string& name) const
     337                 :            :         {
     338                 :        823 :                 ParametersMap::const_iterator it = pmap.find(name);
     339         [ +  + ]:        823 :                 if (it != pmap.end())
     340                 :            :                 {
     341                 :        822 :                         return it->second;
     342                 :            :                 }
     343                 :            :                 else
     344                 :            :                 {
     345 [ +  - ][ +  - ]:          1 :                         throw missed_parameter_error(Message() << "Parameter " << name << " is missed");
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     346                 :            :                 }
     347                 :            :         }
     348                 :        127 :         ParametersSet& operator,(const Parameter& p)
     349                 :            :         {
     350                 :        127 :                 add(p);
     351                 :        126 :                 return *this;
     352                 :            :         }
     353                 :            : 
     354                 :            : private:
     355                 :            : 
     356                 :            :         ParametersMap pmap;
     357                 :            : };
     358                 :            : 
     359                 :         29 : ParametersSet Parameter::operator,(const Parameter& p)
     360                 :            : {
     361                 :         29 :         ParametersSet pg;
     362         [ +  - ]:         29 :         pg.add(*this);
     363         [ +  - ]:         29 :         pg.add(p);
     364                 :         29 :         return pg;
     365                 :            : }
     366                 :            : 
     367                 :         18 : Parameter::operator ParametersSet()
     368                 :            : {
     369                 :         18 :         ParametersSet pg;
     370         [ +  - ]:         18 :         pg.add(*this);
     371                 :         18 :         return pg;
     372                 :            : }
     373                 :            : 
     374                 :            : 
     375                 :            : }
     376                 :            : 
     377                 :            : #endif

Generated by: LCOV version 1.9