bindings/cxx/ConfigKey_methods.cpp

   1 #include <config.h>
   2
   3 const DataType *ConfigKey::data_type() const
   4 {
   5         const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
   6         if (!info)
   7                 throw Error(SR_ERR_NA);
   8         return DataType::get(info->datatype);
   9 }
  10
  11 std::string ConfigKey::identifier() const
  12 {
  13         const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
  14         if (!info)
  15                 throw Error(SR_ERR_NA);
  16         return valid_string(info->id);
  17 }
  18
  19 std::string ConfigKey::description() const
  20 {
  21         const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
  22         if (!info)
  23                 throw Error(SR_ERR_NA);
  24         return valid_string(info->name);
  25 }
  26
  27 const ConfigKey *ConfigKey::get_by_identifier(std::string identifier)
  28 {
  29         const struct sr_key_info *info = sr_key_info_name_get(SR_KEY_CONFIG, identifier.c_str());
  30         if (!info)
  31                 throw Error(SR_ERR_ARG);
  32         return get(info->key);
  33 }
  34
  35 #ifndef HAVE_STOI_STOD
  36
  37 /* Fallback implementation of stoi and stod */
  38
  39 #include <cstdlib>
  40 #include <cerrno>
  41 #include <stdexcept>
  42 #include <limits>
  43
  44 static inline int stoi( const std::string& str )
  45 {
  46         char *endptr;
  47         errno = 0;
  48         const long ret = std::strtol(str.c_str(), &endptr, 10);
  49         if (endptr == str.c_str())
  50                 throw std::invalid_argument("stoi");
  51         else if (errno == ERANGE ||
  52                  ret < std::numeric_limits<int>::min() ||
  53                  ret > std::numeric_limits<int>::max())
  54                 throw std::out_of_range("stoi");
  55         else
  56                 return ret;
  57 }
  58
  59 static inline double stod( const std::string& str )
  60 {
  61         char *endptr;
  62         errno = 0;
  63         const double ret = std::strtod(str.c_str(), &endptr);
  64         if (endptr == str.c_str())
  65                 throw std::invalid_argument("stod");
  66         else if (errno == ERANGE)
  67                 throw std::out_of_range("stod");
  68         else
  69                 return ret;
  70 }
  71 #endif
  72
  73 Glib::VariantBase ConfigKey::parse_string(std::string value, enum sr_datatype dt)
  74 {
  75         GVariant *variant;
  76         uint64_t p, q;
  77
  78         switch (dt)
  79         {
  80                 case SR_T_UINT64:
  81                         check(sr_parse_sizestring(value.c_str(), &p));
  82                         variant = g_variant_new_uint64(p);
  83                         break;
  84                 case SR_T_STRING:
  85                         variant = g_variant_new_string(value.c_str());
  86                         break;
  87                 case SR_T_BOOL:
  88                         variant = g_variant_new_boolean(sr_parse_boolstring(value.c_str()));
  89                         break;
  90                 case SR_T_FLOAT:
  91                         try {
  92                                 variant = g_variant_new_double(stod(value));
  93                         } catch (invalid_argument&) {
  94                                 throw Error(SR_ERR_ARG);
  95                         }
  96                         break;
  97                 case SR_T_RATIONAL_PERIOD:
  98                         check(sr_parse_period(value.c_str(), &p, &q));
  99                         variant = g_variant_new("(tt)", p, q);
 100                         break;
 101                 case SR_T_RATIONAL_VOLT:
 102                         check(sr_parse_voltage(value.c_str(), &p, &q));
 103                         variant = g_variant_new("(tt)", p, q);
 104                         break;
 105                 case SR_T_INT32:
 106                         try {
 107                                 variant = g_variant_new_int32(stoi(value));
 108                         } catch (invalid_argument&) {
 109                                 throw Error(SR_ERR_ARG);
 110                         }
 111                         break;
 112                 default:
 113                         throw Error(SR_ERR_BUG);
 114         }
 115
 116         return Glib::VariantBase(variant, false);
 117 }
 118
 119 Glib::VariantBase ConfigKey::parse_string(std::string value) const
 120 {
 121         enum sr_datatype dt = (enum sr_datatype)(data_type()->id());
 122         return parse_string(value, dt);
 123 }