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         \r
 104         void signal::from_json(const nlohmann::json& j)\r
 105         {\r
 106                 generic_name_ = j.count("generic_name") ? j["generic_name"].get<std::string>() : "";\r
 107                 bit_position_ = j.count("bit_position") ? j["bit_position"].get<std::uint32_t>() : 0;\r
 108                 bit_size_ = j.count("bit_size") ? j["bit_size"].get<std::uint32_t>() : 0;\r
 109                 factor_ = j.count("factor") ? j["factor"].get<float>() : 1.0f;\r
 110                 offset_ = j.count("offset") ? j["offset"].get<float>() : 0.0f;\r
 111                 decoder_ = j.count("decoder") ? j["decoder"].get<std::string>() : "";\r
 112                 ignore_ = j.count("ignore") ? j["ignore"].get<bool>() : false;\r
 113                 enabled_ = j.count("enabled") ? j["enabled"].get<bool>() : true;\r
 114                 max_frequency_ = j.count("max_frequency") ? j["max_frequency"].get<float>() : 0.0f;\r
 115                 send_same_ = j.count("send_same") ? j["send_same"].get<bool>() : true;\r
 116                 force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : false;\r
 117                 writable_ = j.count("writable") ? j["writable"].get<bool>() : false;\r
 118                 encoder_ = j.count("encoder") ? j["encoder"].get<std::string>() : "";\r
 119                 if(j.count("multiplex"))\r
 120                 {\r
 121                         std::string mult = j["multiplex"].get<std::string>();\r
 122                         bool first = false;\r
 123                         int second = 0 ;\r
 124                         if(mult.compare("Multiplexor") == 0){\r
 125                                 first = true;\r
 126                         }\r
 127                         else if (mult.compare("") != 0)\r
 128                         {\r
 129                                 second = std::stoi(mult);\r
 130                         }\r
 131                         multiplex_ = std::make_pair(first,second);\r
 132                 }\r
 133                 else\r
 134                 {\r
 135                         multiplex_ =  std::make_pair(false,0);\r
 136                 }\r
 137                 is_big_endian_ = j.count("is_big_endian") ? j["is_big_endian"].get<bool>() : false;\r
 138                 is_signed_ = j.count("is_signed") ? j["is_signed"].get<bool>() : false;\r
 139                 unit_ = j.count("unit") ? j["unit"].get<std::string>() : "";\r
 140 \r
 141 \r
 142 \r
 143                 if (j.count("states"))\r
 144                 {\r
 145                         std::map<std::string, nlohmann::json> items = j["states"];\r
 146                         for(const auto& i : items)\r
 147                         {\r
 148                                 states_[i.first] = i.second.get<std::vector<std::uint32_t>>();\r
 149                         }\r
 150                 }\r
 151         }\r
 152 \r
 153         nlohmann::json signal::to_json() const\r
 154         {\r
 155                 nlohmann::json j;\r
 156                 j["generic_name"] = generic_name_;\r
 157                 j["bit_position"] = bit_position_;\r
 158                 j["bit_size"] = bit_size_;\r
 159                 j["factor"] = factor_;\r
 160                 j["offset"] = offset_;\r
 161                 j["decoder"] = decoder_;\r
 162                 j["ignore"] = ignore_;\r
 163                 j["enabled"] = enabled_;\r
 164                 j["states"] = states_;\r
 165                 j["max_frequency"] = max_frequency_;\r
 166                 j["send_same"] = send_same_;\r
 167                 j["force_send_changed"] = force_send_changed_;\r
 168                 j["writable"] = writable_;\r
 169                 j["encoder"] = encoder_;\r
 170 \r
 171                 std::string multi = "";\r
 172 \r
 173                 if(multiplex_.first)\r
 174                 {\r
 175                         multi = "Multiplexor";\r
 176                 }\r
 177                 else if(multiplex_.second != 0)\r
 178                 {\r
 179                         multi = std::to_string(multiplex_.second);\r
 180                 }\r
 181                 else\r
 182                 {\r
 183                         multi = "";\r
 184                 }\r
 185 \r
 186                 j["multiplex"] = multi;\r
 187 \r
 188 \r
 189 \r
 190                 j["is_big_endian"] = is_big_endian_;\r
 191                 j["is_signed"] = is_signed_;\r
 192                 j["unit"] = unit_;\r
 193                 return j;\r
 194         }\r
 195 \r
 196         void to_json(nlohmann::json& j, const signal& p)\r
 197         {\r
 198                 j = p.to_json();\r
 199         }\r
 200 \r
 201         void from_json(const nlohmann::json& j, signal& p)\r
 202         {\r
 203                 p.from_json(j);\r
 204         }\r
 205 }\r