src/openxc/message_set.cpp

   1 #include <sstream>\r
   2 #include "message_set.hpp"\r
   3 \r
   4 namespace openxc\r
   5 {\r
   6         message_set::message_set()\r
   7                 : name_{""}\r
   8                 , version_{"1.0"}\r
   9                 , bit_numbering_inverted_{false}\r
  10                 , max_message_frequency_{0}\r
  11                 , raw_can_mode_{can_bus_mode::off}\r
  12                 , parents_{}\r
  13                 , initializers_{}\r
  14                 , loopers_{}\r
  15                 , buses_{}\r
  16                 , messages_{}\r
  17                 , diagnostic_messages_{}\r
  18                 , mappings_{}\r
  19                 , extra_sources_{}\r
  20                 , commands_{}\r
  21         {\r
  22         }\r
  23 \r
  24         std::string message_set::name() const\r
  25         {\r
  26                 return name_;\r
  27         }\r
  28 \r
  29         std::string message_set::version() const\r
  30         {\r
  31                 return version_;\r
  32         }\r
  33 \r
  34         bool message_set::bit_numbering_inverted() const\r
  35         {\r
  36                 return bit_numbering_inverted_;\r
  37         }\r
  38 \r
  39         float message_set::max_message_frequency() const\r
  40         {\r
  41                 return max_message_frequency_;\r
  42         }\r
  43 \r
  44         can_bus_mode message_set::raw_can_mode() const\r
  45         {\r
  46                 return raw_can_mode_;\r
  47         }\r
  48 \r
  49         const std::vector<std::string>& message_set::parents() const\r
  50         {\r
  51                 return parents_;\r
  52         }\r
  53 \r
  54         const std::vector<std::string>& message_set::initializers() const\r
  55         {\r
  56                 return initializers_;\r
  57         }\r
  58 \r
  59         const std::vector<std::string>& message_set::loopers() const\r
  60         {\r
  61                 return loopers_;\r
  62         }\r
  63 \r
  64         const std::map<std::string, can_bus>& message_set::buses() const\r
  65         {\r
  66                 return buses_;\r
  67         }\r
  68 \r
  69         const std::vector<can_message>& message_set::messages() const\r
  70         {\r
  71                 return messages_;\r
  72         }\r
  73 \r
  74         const std::vector<diagnostic_message>& message_set::diagnostic_messages() const\r
  75         {\r
  76                 return diagnostic_messages_;\r
  77         }\r
  78 \r
  79         const std::vector<mapping>& message_set::mappings() const\r
  80         {\r
  81                 return mappings_;\r
  82         }\r
  83 \r
  84         const std::vector<std::string>& message_set::extra_sources() const\r
  85         {\r
  86                 return extra_sources_;\r
  87         }\r
  88 \r
  89         const std::vector<command>& message_set::commands() const\r
  90         {\r
  91                 return commands_;\r
  92         }\r
  93 \r
  94         void message_set::from_json(const nlohmann::json& j)\r
  95         {\r
  96                 name_ = j["name"].get<std::string>();\r
  97                 version_ = j["version"].get<std::string>();\r
  98                 bit_numbering_inverted_ = j.count("bit_numbering_inverted") ? j["bit_numbering_inverted"].get<bool>() : false; // TODO: should be true by default if database-backed.\r
  99                 max_message_frequency_ = j.count("max_message_frequency") ? j["max_message_frequency"].get<float>() : 0.0f;\r
 100                 raw_can_mode_ = j.count("raw_can_mode") ? j["raw_can_mode"].get<can_bus_mode>() : can_bus_mode::off;\r
 101                 parents_ = j.count("parents") ? j["parents"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 102                 initializers_ = j.count("initializers") ? j["initializers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 103                 loopers_ = j.count("loopers") ? j["loopers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 104                 buses_ = j.count("buses") ? j["buses"].get<std::map<std::string, can_bus>>() : std::map<std::string, can_bus>();\r
 105                 //messages_ = j.count("messages") ? j["messages"].get<std::map<std::string, can_message>>() : std::map<std::string, can_message>();\r
 106                 diagnostic_messages_ = j.count("diagnostic_messages") ? j["diagnostic_messages"].get<std::vector<diagnostic_message>>() : std::vector<diagnostic_message>();\r
 107                 mappings_ = j.count("mappings") ? j["mappings"].get<std::vector<mapping>>() : std::vector<mapping>();\r
 108                 extra_sources_ = j.count("extra_sources") ? j["extra_sources"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 109                 commands_ = j.count("commands") ? j["commands"].get<std::vector<command>>() : std::vector<command>();\r
 110 \r
 111 \r
 112                 if (j.count("messages"))\r
 113                 {\r
 114                         std::map<std::string, nlohmann::json> messages = j["messages"];\r
 115                         for(const std::map<std::string, nlohmann::json>::value_type& m : messages)\r
 116                         {\r
 117                                 can_message cm = m.second.get<can_message>();\r
 118                                 cm.id(m.first);\r
 119                                 messages_.push_back(cm);\r
 120                         }\r
 121                 }\r
 122         }\r
 123 \r
 124         nlohmann::json message_set::to_json() const\r
 125         {\r
 126                 nlohmann::json j;\r
 127                 j["name"]                                               = name_;\r
 128                 j["version"]                                    = version_;\r
 129                 j["bit_numbering_inverted"]             = bit_numbering_inverted_;\r
 130                 j["max_message_frequency"]              = max_message_frequency_;\r
 131                 j["raw_can_mode"]                               = raw_can_mode_;\r
 132                 j["parents"]                                    = parents_;\r
 133                 j["initializers"]                               = initializers_;\r
 134                 j["loopers"]                                    = loopers_;\r
 135                 j["buses"]                                              = buses_;\r
 136                 j["messages"]                                   = messages_;\r
 137                 j["diagnostic_messages"]                = diagnostic_messages_;\r
 138                 j["mappings"]                                   = mappings_;\r
 139                 j["extra_sources"]                              = extra_sources_;\r
 140                 j["commands"]                                   = commands_;\r
 141                 return j;\r
 142         }\r
 143 \r
 144         void to_json(nlohmann::json& j, const message_set& p)\r
 145         {\r
 146                 j = p.to_json();\r
 147         }\r
 148 \r
 149         void from_json(const nlohmann::json& j, message_set& p)\r
 150         {\r
 151                 p.from_json(j);\r
 152         }\r
 153 }\r