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         std::uint32_t 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::map<std::string, 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         std::string message_set::to_initializer() const\r
  89         {\r
  90                 std::uint32_t signal_count = 0;\r
  91                 for(const auto& m : messages_)\r
  92                 {\r
  93                         signal_count += m.second.get_signals_count();\r
  94                 }\r
  95                 \r
  96                 std::stringstream ss;\r
  97                 ss      << "{0, "\r
  98                         << "\"" << name_ << "\", "\r
  99                         << buses_.size() << ", "\r
 100                         << messages_.size() << ", "\r
 101                         << signal_count << ", "\r
 102                         << commands_.size() << ", "\r
 103                         << diagnostic_messages_.size() << "}";\r
 104                 return ss.str();\r
 105         }\r
 106 \r
 107         void message_set::from_json(const nlohmann::json& j)\r
 108         {\r
 109                 name_ = j["name"].get<std::string>();\r
 110                 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
 111                 max_message_frequency_ = j.count("max_message_frequency") ? j["max_message_frequency"].get<std::uint32_t>() : 0;\r
 112                 raw_can_mode_ = j.count("raw_can_mode") ? j["raw_can_mode"].get<can_bus_mode>() : can_bus_mode::off;\r
 113                 parents_ = j.count("parents") ? j["parents"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 114                 initializers_ = j.count("initializers") ? j["initializers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 115                 loopers_ = j.count("loopers") ? j["loopers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 116                 buses_ = j.count("buses") ? j["buses"].get<std::map<std::string, can_bus>>() : std::map<std::string, can_bus>();\r
 117                 messages_ = j.count("messages") ? j["messages"].get<std::map<std::string, can_message>>() : std::map<std::string, can_message>();\r
 118                 diagnostic_messages_ = j.count("diagnostic_messages") ? j["diagnostic_messages"].get<std::vector<diagnostic_message>>() : std::vector<diagnostic_message>();\r
 119                 mappings_ = j.count("mappings") ? j["mappings"].get<std::vector<mapping>>() : std::vector<mapping>();\r
 120                 extra_sources_ = j.count("extra_sources") ? j["extra_sources"].get<std::vector<std::string>>() : std::vector<std::string>();\r
 121                 commands_ = j.count("commands") ? j["commands"].get<std::vector<command>>() : std::vector<command>();\r
 122         }\r
 123 \r
 124 \r
 125         nlohmann::json message_set::to_json() const\r
 126         {\r
 127                 nlohmann::json j;\r
 128                 j["name_"]                                              = name_;\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