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         void signal::from_json(const nlohmann::json& j)\r
  88         {\r
  89                 generic_name_ = j.count("generic_name") ? j["generic_name"].get<std::string>() : "";\r
  90                 bit_position_ = j.count("bit_position") ? j["bit_position"].get<std::uint32_t>() : 0;\r
  91                 bit_size_ = j.count("bit_size") ? j["bit_size"].get<std::uint32_t>() : 0;\r
  92                 factor_ = j.count("factor") ? j["factor"].get<float>() : 1.0f;\r
  93                 offset_ = j.count("offset") ? j["offset"].get<float>() : 0.0f;\r
  94                 decoder_ = j.count("decoder") ? j["decoder"].get<std::string>() : "";\r
  95                 ignore_ = j.count("ignore") ? j["ignore"].get<bool>() : false;\r
  96                 enabled_ = j.count("enabled") ? j["enabled"].get<bool>() : true;\r
  97                 max_frequency_ = j.count("max_frequency") ? j["max_frequency"].get<float>() : 0.0f;\r
  98                 send_same_ = j.count("send_same") ? j["send_same"].get<bool>() : true;\r
  99                 force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : false;\r
 100                 writable_ = j.count("writable") ? j["writable"].get<bool>() : false;\r
 101                 encoder_ = j.count("encoder") ? j["encoder"].get<std::string>() : "";\r
 102 \r
 103                 if (j.count("states"))\r
 104                 {\r
 105                         std::map<std::string, nlohmann::json> items = j["states"];\r
 106                         for(const auto& i : items)\r
 107                         {\r
 108                                 states_[i.first] = i.second.get<std::vector<std::uint32_t>>();\r
 109                         }\r
 110                 }\r
 111         }\r
 112 \r
 113         nlohmann::json signal::to_json() const\r
 114         {\r
 115                 nlohmann::json j;\r
 116                 j["generic_name"] = generic_name_;\r
 117                 j["bit_position"] = bit_position_;\r
 118                 j["bit_size"] = bit_size_;\r
 119                 j["factor"] = factor_;\r
 120                 j["offset"] = offset_;\r
 121                 j["decoder"] = decoder_;\r
 122                 j["ignore"] = ignore_;\r
 123                 j["enabled"] = enabled_;\r
 124                 j["states"] = states_;\r
 125                 j["max_frequency"] = max_frequency_;\r
 126                 j["send_same"] = send_same_;\r
 127                 j["force_send_changed"] = force_send_changed_;\r
 128                 j["writable"] = writable_;\r
 129                 j["encoder"] = encoder_;\r
 130                 return j;\r
 131         }\r
 132 \r
 133         void to_json(nlohmann::json& j, const signal& p)\r
 134         {\r
 135                 j = p.to_json();\r
 136         }\r
 137 \r
 138         void from_json(const nlohmann::json& j, signal& p)\r
 139         {\r
 140                 p.from_json(j);\r
 141         }\r
 142 }\r