src/openxc/signal.cpp

   1 #include "signal.hpp"\r
   2 \r
   3 namespace openxc\r
   4 {\r
   5         std::string signal::id() const\r
   6         {\r
   7                 return id_;\r
   8         }\r
   9 \r
  10         void signal::id(const std::string& id)\r
  11         {\r
  12                 id_ = id;\r
  13         }\r
  14 \r
  15         void id(const std::string& id);\r
  16 \r
  17         std::string signal::generic_name() const\r
  18         {\r
  19                 return generic_name_;\r
  20         }\r
  21 \r
  22         std::uint32_t signal::bit_position() const\r
  23         {\r
  24                 return bit_position_;\r
  25         }\r
  26 \r
  27         std::uint32_t signal::bit_size() const\r
  28         {\r
  29                 return bit_size_;\r
  30         }\r
  31 \r
  32         float signal::factor() const\r
  33         {\r
  34                 return factor_;\r
  35         }\r
  36 \r
  37         float signal::offset() const\r
  38         {\r
  39                 return offset_;\r
  40         }\r
  41 \r
  42         std::string signal::decoder() const\r
  43         {\r
  44                 return decoder_;\r
  45         }\r
  46 \r
  47         bool signal::ignore() const\r
  48         {\r
  49                 return ignore_;\r
  50         }\r
  51 \r
  52         bool signal::enabled() const\r
  53         {\r
  54                 return enabled_;\r
  55         }\r
  56 \r
  57         const std::map<std::string, std::vector<std::uint32_t>>& signal::states() const\r
  58         {\r
  59                 return states_;\r
  60         }\r
  61 \r
  62         float signal::max_frequency() const\r
  63         {\r
  64                 return max_frequency_;\r
  65         }\r
  66 \r
  67         bool signal::send_same() const\r
  68         {\r
  69                 return send_same_;\r
  70         }\r
  71 \r
  72         bool signal::force_send_changed() const\r
  73         {\r
  74                 return force_send_changed_;\r
  75         }\r
  76 \r
  77         bool signal::writable() const\r
  78         {\r
  79                 return writable_;\r
  80         }\r
  81 \r
  82         std::string signal::encoder() const\r
  83         {\r
  84                 return encoder_;\r
  85         }\r
  86 \r
  87         std::pair<bool,int> signal::multiplex() const{\r
  88                 return multiplex_;\r
  89         }\r
  90 \r
  91         bool signal::is_big_endian() const{\r
  92                 return is_big_endian_;\r
  93         }\r
  94 \r
  95         bool signal::is_signed() const{\r
  96                 return is_signed_;\r
  97         }\r
  98 \r
  99         std::string signal::unit() const{\r
 100                 return unit_;\r
 101         }\r
 102 \r
 103         void signal::from_json(const nlohmann::json& j)\r
 104         {\r
 105                 generic_name_ = j.count("generic_name") ? j["generic_name"].get<std::string>() : "";\r
 106                 bit_position_ = j.count("bit_position") ? j["bit_position"].get<std::uint32_t>() : 0;\r
 107                 bit_size_ = j.count("bit_size") ? j["bit_size"].get<std::uint32_t>() : 0;\r
 108                 factor_ = j.count("factor") ? j["factor"].get<float>() : 1.0f;\r
 109                 offset_ = j.count("offset") ? j["offset"].get<float>() : 0.0f;\r
 110                 decoder_ = j.count("decoder") ? j["decoder"].get<std::string>() : "";\r
 111                 ignore_ = j.count("ignore") ? j["ignore"].get<bool>() : false;\r
 112                 enabled_ = j.count("enabled") ? j["enabled"].get<bool>() : true;\r
 113                 max_frequency_ = j.count("max_frequency") ? j["max_frequency"].get<float>() : 0.0f;\r
 114                 send_same_ = j.count("send_same") ? j["send_same"].get<bool>() : true;\r
 115                 force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : false;\r
 116                 writable_ = j.count("writable") ? j["writable"].get<bool>() : false;\r
 117                 encoder_ = j.count("encoder") ? j["encoder"].get<std::string>() : "";\r
 118                 if(j.count("multiplex"))\r
 119                 {\r
 120                         std::string mult = j["multiplex"].get<std::string>();\r
 121                         bool first = false;\r
 122                         int second = 0 ;\r
 123                         if(mult.compare("Multiplexor") == 0){\r
 124                                 first = true;\r
 125                         }\r
 126                         else if (mult.compare("") != 0)\r
 127                         {\r
 128                                 second = std::stoi(mult);\r
 129                         }\r
 130                         multiplex_ = std::make_pair(first,second);\r
 131                 }\r
 132                 else\r
 133                 {\r
 134                         multiplex_ =  std::make_pair(false,0);\r
 135                 }\r
 136                 is_big_endian_ = j.count("is_big_endian") ? j["is_big_endian"].get<bool>() : false;\r
 137                 is_signed_ = j.count("is_signed") ? j["is_signed"].get<bool>() : false;\r
 138                 unit_ = j.count("unit") ? j["unit"].get<std::string>() : "";\r
 139 \r
 140 \r
 141 \r
 142                 if (j.count("states"))\r
 143                 {\r
 144                         std::map<std::string, nlohmann::json> items = j["states"];\r
 145                         for(const auto& i : items)\r
 146                         {\r
 147                                 states_[i.first] = i.second.get<std::vector<std::uint32_t>>();\r
 148                         }\r
 149                 }\r
 150         }\r
 151 \r
 152         nlohmann::json signal::to_json() const\r
 153         {\r
 154                 nlohmann::json j;\r
 155                 j["generic_name"] = generic_name_;\r
 156                 j["bit_position"] = bit_position_;\r
 157                 j["bit_size"] = bit_size_;\r
 158                 j["factor"] = factor_;\r
 159                 j["offset"] = offset_;\r
 160                 j["decoder"] = decoder_;\r
 161                 j["ignore"] = ignore_;\r
 162                 j["enabled"] = enabled_;\r
 163                 j["states"] = states_;\r
 164                 j["max_frequency"] = max_frequency_;\r
 165                 j["send_same"] = send_same_;\r
 166                 j["force_send_changed"] = force_send_changed_;\r
 167                 j["writable"] = writable_;\r
 168                 j["encoder"] = encoder_;\r
 169 \r
 170                 std::string multi = "";\r
 171 \r
 172                 if(multiplex_.first)\r
 173                 {\r
 174                         multi = "Multiplexor";\r
 175                 }\r
 176                 else if(multiplex_.second != 0)\r
 177                 {\r
 178                         multi = std::to_string(multiplex_.second);\r
 179                 }\r
 180                 else\r
 181                 {\r
 182                         multi = "";\r
 183                 }\r
 184 \r
 185                 j["multiplex"] = multi;\r
 186 \r
 187 \r
 188 \r
 189                 j["is_big_endian"] = is_big_endian_;\r
 190                 j["is_signed"] = is_signed_;\r
 191                 j["unit"] = unit_;\r
 192                 return j;\r
 193         }\r
 194 \r
 195         void to_json(nlohmann::json& j, const signal& p)\r
 196         {\r
 197                 j = p.to_json();\r
 198         }\r
 199 \r
 200         void from_json(const nlohmann::json& j, signal& p)\r
 201         {\r
 202                 p.from_json(j);\r
 203         }\r
 204 }\r