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