| LCOV - code coverage report | |||||||||||||||||||||||||||||
 | |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #include "dbc_statement_handler.h" + 3 : : #include <charconv> + 4 : : #include <cmath> + 5 : : #include <limits> + 6 : : #include <set> + 7 : : + 8 : : namespace { + 9 : : struct Token { + 10 : : std::string text; + 11 : : bool quoted = false; + 12 : : }; + 13 : : + 14 : 621 : std::vector<Token> Tokenize(const std::string &text) { + 15 : 621 : std::vector<Token> tokens; + 16 : 621 : std::size_t index = 0U; + 17 [ + + ]: 6141 : while (index < text.size()) { + 18 : 5528 : const char character = text[index++]; + 19 [ + + - + ]: 5528 : if (character == ' ' || character == '\t') + 20 : 2138 : continue; + 21 : 3390 : Token token; + 22 [ + + ]: 3390 : if (character == '"') { + 23 : 652 : token.quoted = true; + 24 : 652 : bool closed = false; + 25 [ + + ]: 1938 : while (index < text.size()) { + 26 : 1936 : char next = text[index++]; + 27 [ + + ]: 1936 : if (next == '"') { + 28 : 648 : closed = true; + 29 : 648 : break; + 30 : : } + 31 [ + + ]: 1288 : if (next == '\\') { + 32 [ - + ]: 4 : if (index == text.size()) + 33 [ # # ]: 0 : throw std::runtime_error("Incomplete attribute escape."); + 34 : 4 : next = text[index++]; + 35 [ + + + + ]: 4 : if (next != '"' && next != '\\') + 36 [ + - ]: 2 : throw std::runtime_error("Invalid attribute escape."); + 37 : : } + 38 [ + - ]: 1286 : token.text += next; + 39 : : } + 40 [ + + ]: 650 : if (!closed) + 41 [ + - ]: 2 : throw std::runtime_error("Unterminated attribute string."); + 42 [ + + + - ]: 1296 : if (index < text.size() && text[index] != ' ' && text[index] != '\t' && + 43 [ + - + + : 1296 : text[index] != ',' && text[index] != ';') + + + + + ] + 44 [ + - ]: 2 : throw std::runtime_error("Missing separator after attribute string."); + 45 [ + + + + ]: 2738 : } else if (character == ';' || character == ',') { + 46 [ + - ]: 623 : token.text = character; + 47 : : } else { + 48 [ + - ]: 2115 : token.text = character; + 49 [ + + + - ]: 18280 : while (index < text.size() && text[index] != ' ' && text[index] != '\t' && + 50 [ + + + + : 18280 : text[index] != ';' && text[index] != ',') { + + - + + ] + 51 [ + + ]: 7028 : if (text[index] == '"') + 52 [ + - ]: 2 : throw std::runtime_error("Missing separator before attribute string."); + 53 [ + - ]: 7026 : token.text += text[index++]; + 54 : : } + 55 : : } + 56 [ + - ]: 3382 : tokens.push_back(token); + 57 : 3390 : } + 58 [ + - + - : 613 : if (tokens.empty() || tokens.back().quoted || tokens.back().text != ";") + + - + + + + + ] + 59 [ + - ]: 2 : throw std::runtime_error("Attribute statement requires a semicolon."); + 60 : 611 : tokens.pop_back(); + 61 : 611 : return tokens; + 62 : 10 : } + 63 : : + 64 : : class AttributeTokens { + 65 : : public: + 66 : 621 : explicit AttributeTokens(const std::string &line) : tokens(Tokenize(line)) {} + 67 : 2639 : Token Take() { + 68 [ + + ]: 2639 : if (position == tokens.size()) + 69 [ + - ]: 4 : throw std::runtime_error("Incomplete attribute statement."); + 70 : 2635 : return tokens[position++]; + 71 : : } + 72 : 1681 : std::string Word() { + 73 [ + - ]: 1681 : const Token token = Take(); + 74 [ + + + - : 1681 : if (token.quoted || token.text == "," || token.text == ";") + + - + - - + + + + ] + 75 [ + - ]: 2 : throw std::runtime_error("Expected an attribute keyword or number."); + 76 [ + - ]: 3358 : return token.text; + 77 : 1681 : } + 78 : 315 : std::string Quoted() { + 79 [ + + ]: 315 : const Token token = Take(); + 80 [ + + ]: 311 : if (!token.quoted) + 81 [ + - ]: 2 : throw std::runtime_error("Expected a quoted attribute name or string."); + 82 [ + - ]: 618 : return token.text; + 83 : 311 : } + 84 : 262 : bool Empty() const { return position == tokens.size(); } + 85 : 245 : void End() const { + 86 [ - + ]: 245 : if (!Empty()) + 87 [ # # ]: 0 : throw std::runtime_error("Unexpected trailing attribute fields."); + 88 : 245 : } + 89 : : + 90 : : private: + 91 : : std::vector<Token> tokens; + 92 : : std::size_t position = 0U; + 93 : : }; + 94 : : + 95 : 115 : bool IsScope(const std::string &text) { + 96 [ + + + + : 115 : return text == "BO_" || text == "SG_" || text == "BU_" || text == "EV_"; + + + + + ] + 97 : : } + 98 : : + 99 : 110 : AttributeScope ParseScope(const std::string &text) { + 100 [ + + ]: 110 : if (text == "BO_") return AttributeScope::Frame; + 101 [ + + ]: 17 : if (text == "SG_") return AttributeScope::Signal; + 102 [ + + ]: 6 : if (text == "BU_") return AttributeScope::Node; + 103 [ + + ]: 4 : if (text == "EV_") return AttributeScope::Environment; + 104 [ + - + - ]: 2 : throw std::runtime_error("Unsupported attribute scope: " + text); + 105 : : } + 106 : : + 107 : : template<class Numeric> + 108 : 866 : Numeric ParseNumber(const std::string &text) { + 109 : 866 : const char *begin = text.data(); + 110 : 866 : const char *end = begin + text.size(); + 111 [ + - + + ]: 866 : if (begin != end && *begin == '+') { + 112 : 78 : ++begin; + 113 [ + + + + : 78 : if (begin != end && (*begin == '-' || *begin == '+')) + + + ] + 114 [ + - + - ]: 48 : throw std::runtime_error("Invalid attribute number: " + text); + 115 : : } + 116 : 818 : Numeric value = 0; + 117 [ + - ]: 818 : const std::from_chars_result parsed = std::from_chars(begin, end, value); + 118 [ + + + + : 818 : if (begin == end || parsed.ec != std::errc() || parsed.ptr != end || !std::isfinite(value)) + + + + + + + + ] + 119 [ + - + - ]: 270 : throw std::runtime_error("Invalid attribute number: " + text); + 120 : 548 : return value; + 121 : : } + 122 : : + 123 : 204 : AttributeValue Value(const Token &token, const AttributeDefinition &definition, bool isDefault) { + 124 [ + + ]: 204 : if (definition.type == AttributeType::String) { + 125 [ + + + - ]: 6 : if (!token.quoted) throw std::runtime_error("Attribute STRING requires quoted text."); + 126 [ + - ]: 4 : return token.text; + 127 : : } + 128 [ + + + + : 198 : if (definition.type == AttributeType::Enum && isDefault && token.quoted) { + + + ] + 129 [ + + ]: 9 : for (std::size_t index = 0U; index < definition.enumValues.size(); ++index) { + 130 [ + + ]: 7 : if (definition.enumValues[index] == token.text) + 131 : 2 : return static_cast<std::int64_t>(index); + 132 : : } + 133 [ + - ]: 2 : throw std::runtime_error("Unknown attribute ENUM default label."); + 134 : : } + 135 [ + + + - ]: 194 : if (token.quoted) throw std::runtime_error("Numeric attribute requires an unquoted number."); + 136 [ + + ]: 192 : if (definition.type == AttributeType::Float) { + 137 [ + + ]: 53 : const double value = ParseNumber<double>(token.text); + 138 [ + - + + ]: 5 : if (value < definition.minimum || value > definition.maximum) + 139 [ + - ]: 2 : throw std::runtime_error("Attribute FLOAT value outside definition range."); + 140 : 3 : return value; + 141 : : } + 142 [ + + ]: 139 : const std::int64_t value = ParseNumber<std::int64_t>(token.text); + 143 [ + - + + ]: 31 : if (value < definition.integerMinimum || value > definition.integerMaximum) + 144 [ + - ]: 4 : throw std::runtime_error("Attribute integer/ENUM value outside definition range."); + 145 : 27 : return value; + 146 : : } + 147 : : + 148 : 393 : void Define(AttributeTokens &tokens, DbcDatabase &database) { + 149 : 393 : AttributeDefinition definition; + 150 [ + - ]: 393 : const Token first = tokens.Take(); + 151 [ + - ]: 393 : std::string name = first.text; + 152 [ + + ]: 393 : if (!first.quoted) { + 153 [ + + ]: 76 : definition.scope = ParseScope(first.text); + 154 [ + + ]: 74 : name = tokens.Quoted(); + 155 : : } + 156 [ - + - - ]: 389 : if (name.empty()) throw std::runtime_error("Empty attribute name."); + 157 [ + + ]: 389 : const std::string type = tokens.Word(); + 158 [ + - + + : 387 : if (type == "INT" || type == "HEX") { + + - + + + + + ] + 159 [ + - + + ]: 255 : definition.type = type == "INT" ? AttributeType::Integer : AttributeType::Hex; + 160 [ + - + + ]: 309 : definition.integerMinimum = ParseNumber<std::int64_t>(tokens.Word()); + 161 [ + - + + ]: 257 : definition.integerMaximum = ParseNumber<std::int64_t>(tokens.Word()); + 162 [ + + ]: 145 : if (definition.integerMinimum > definition.integerMaximum) + 163 [ + - ]: 2 : throw std::runtime_error("Reversed attribute integer range."); + 164 [ + - + + ]: 132 : } else if (type == "FLOAT") { + 165 : 106 : definition.type = AttributeType::Float; + 166 [ + - + + ]: 132 : definition.minimum = ParseNumber<double>(tokens.Word()); + 167 [ + - + + ]: 106 : definition.maximum = ParseNumber<double>(tokens.Word()); + 168 [ + + ]: 54 : if (definition.minimum > definition.maximum) + 169 [ + - ]: 2 : throw std::runtime_error("Reversed attribute FLOAT range."); + 170 [ + - + + ]: 26 : } else if (type == "STRING") { + 171 : 11 : definition.type = AttributeType::String; + 172 [ + - + + ]: 15 : } else if (type == "ENUM") { + 173 : 13 : definition.type = AttributeType::Enum; + 174 : 13 : std::set<std::string> labels; + 175 : : for (;;) { + 176 [ + + ]: 23 : const std::string label = tokens.Quoted(); + 177 [ + - + + ]: 19 : if (!labels.insert(label).second) + 178 [ + - ]: 2 : throw std::runtime_error("Duplicate attribute ENUM label."); + 179 [ + - ]: 17 : definition.enumValues.push_back(label); + 180 [ + + ]: 17 : if (tokens.Empty()) break; + 181 [ + - ]: 10 : const Token separator = tokens.Take(); + 182 [ + - + - : 10 : if (separator.quoted || separator.text != ",") throw std::runtime_error("Expected ENUM comma."); + - + - + - + - ] + 183 [ + + ]: 29 : } + 184 : 7 : definition.integerMaximum = static_cast<std::int64_t>(definition.enumValues.size() - 1U); + 185 : 13 : } else { + 186 [ + - + - ]: 2 : throw std::runtime_error("Unsupported attribute definition type: " + type); + 187 : : } + 188 [ + - ]: 213 : tokens.End(); + 189 [ + - + + : 213 : if (name == "VFrameFormat" && (definition.scope != AttributeScope::Frame || definition.type != AttributeType::Enum)) + + - + + + + + ] + 190 [ + - ]: 2 : throw std::runtime_error("VFrameFormat requires a BO_ ENUM definition."); + 191 [ + - + + : 217 : if (name == "GenMsgCycleTime" && (definition.scope != AttributeScope::Frame || + + + + + ] + 192 [ - + - - ]: 6 : (definition.type != AttributeType::Integer && definition.type != AttributeType::Hex))) + 193 [ + - ]: 2 : throw std::runtime_error("GenMsgCycleTime requires a BO_ integer definition."); + 194 [ + - + + ]: 209 : if (!database.attributeDefinitions.emplace(name, definition).second) + 195 [ + - + - ]: 2 : throw std::runtime_error("Duplicate attribute definition: " + name); + 196 : 945 : } + 197 : : + 198 : 218 : AttributeDefinition &FindDefinition(DbcDatabase &database, const std::string &name) { + 199 [ + - ]: 218 : const std::map<std::string, AttributeDefinition>::iterator found = database.attributeDefinitions.find(name); + 200 [ + + ]: 218 : if (found == database.attributeDefinitions.end()) + 201 [ + - + - ]: 4 : throw std::runtime_error("Undefined attribute: " + name); + 202 : 428 : return found->second; + 203 : : } + 204 : : + 205 : 32 : void ParseId(const std::string &text, AttributeAssignment &assignment) { + 206 : 32 : const std::int64_t raw = ParseNumber<std::int64_t>(text); + 207 [ + + + + : 32 : if (raw < 0 || raw > std::numeric_limits<std::uint32_t>::max() || (raw & 0x60000000U) != 0) + + + + + ] + 208 [ + - ]: 6 : throw std::runtime_error("Invalid attribute CAN ID."); + 209 : 26 : const std::uint32_t id = static_cast<std::uint32_t>(raw); + 210 : 26 : assignment.canId = id & 0x1fffffffU; + 211 [ + + - + ]: 26 : assignment.isExtended = (id & 0x80000000U) != 0U || id > 0x7ffU; + 212 : 26 : } + 213 : : + 214 : 15 : AttributeMap &Target(DbcDatabase &database, const AttributeAssignment &assignment) { + 215 [ + + ]: 15 : if (assignment.scope == AttributeScope::Database) return database.attributes; + 216 [ + + ]: 16 : for (FrameInfo &frame: database.frames) { + 217 [ + + + + ]: 14 : if (frame.canId != assignment.canId || frame.isExtended != assignment.isExtended) continue; + 218 [ + + ]: 11 : if (assignment.scope == AttributeScope::Frame) return frame.attributes; + 219 [ + + ]: 3 : for (SignalInfo &signal: frame.signals) { + 220 [ + - ]: 1 : if (signal.name == assignment.targetName) return signal.attributes; + 221 : : } + 222 [ + - + - ]: 2 : throw std::runtime_error("Unresolved attribute signal: " + assignment.targetName); + 223 : : } + 224 [ + - ]: 2 : throw std::runtime_error("Unresolved attribute frame."); + 225 : : } + 226 : : + 227 : 36 : void ValidateCycleTime(const std::string &name, const AttributeValue &value) { + 228 [ + + ]: 36 : if (name != "GenMsgCycleTime") return; + 229 : 8 : const std::int64_t milliseconds = std::get<std::int64_t>(value); + 230 [ + + + + : 8 : if (milliseconds < 0 || milliseconds > std::numeric_limits<std::uint32_t>::max()) + + + ] + 231 [ + - ]: 4 : throw std::runtime_error("GenMsgCycleTime must fit unsigned 32-bit milliseconds."); + 232 : : } + 233 : : + 234 : 15 : void ApplyDefault(DbcDatabase &database, const std::string &name, const AttributeDefinition &definition) { + 235 [ - + ]: 15 : if (!definition.defaultValue) return; + 236 [ + + ]: 15 : if (definition.scope == AttributeScope::Database) { + 237 : 5 : database.attributes[name] = *definition.defaultValue; + 238 : 5 : return; + 239 : : } + 240 [ + + - + ]: 10 : if (definition.scope != AttributeScope::Frame && definition.scope != AttributeScope::Signal) + 241 : 0 : return; + 242 [ + + ]: 28 : for (FrameInfo &frame: database.frames) { + 243 [ + + + - : 18 : if (definition.scope == AttributeScope::Frame) frame.attributes[name] = *definition.defaultValue; + + - ] + 244 [ + + ]: 18 : if (definition.scope == AttributeScope::Signal) { + 245 [ + - + - : 6 : for (SignalInfo &signal: frame.signals) signal.attributes[name] = *definition.defaultValue; + + + ] + 246 : : } + 247 : : } + 248 : : } + 249 : : }// namespace + 250 : : + 251 : 621 : void DbcAttributeHandler::Handle(const std::string &line, DbcParseContext &context) const { + 252 : 621 : context.pendingAttributes.push_back({line, context.lineNumber}); + 253 [ + - + - : 1242 : } + - - ] + 254 : : + 255 : 549 : void DbcParseContext::ResolveAttributes(const std::string &filePath, std::vector<DbcDiagnostic> &diagnostics) { + 256 : 549 : std::map<std::string, std::size_t> defaultLines; + 257 : 549 : std::vector<std::size_t> assignmentLines; + 258 : : // Resolve each phase independently of source ordering. + 259 : 549 : const char *keywords[] = {"BA_DEF_", "BA_DEF_DEF_", "BA_"}; + 260 [ + + ]: 1340 : for (const char *phase: keywords) { + 261 [ + + ]: 2094 : for (const PendingAttribute &pending: pendingAttributes) { + 262 [ + - ]: 1303 : const std::string keyword = pending.statement.substr(0U, pending.statement.find_first_of(" \t")); + 263 [ + - + + ]: 1303 : if (keyword != phase) continue; + 264 : : try { + 265 [ + + ]: 621 : AttributeTokens tokens(pending.statement); + 266 [ + - ]: 611 : tokens.Word(); + 267 [ + - + + ]: 611 : if (keyword == "BA_DEF_") { + 268 [ + + ]: 393 : Define(tokens, database); + 269 : 207 : continue; + 270 : : } + 271 [ + - ]: 218 : const std::string name = tokens.Quoted(); + 272 [ + + ]: 218 : AttributeDefinition &definition = FindDefinition(database, name); + 273 [ + - + + ]: 214 : if (keyword == "BA_DEF_DEF_") { + 274 [ + + + - : 99 : if (definition.defaultValue) throw std::runtime_error("Duplicate attribute default: " + name); + + - ] + 275 [ + - + + ]: 177 : definition.defaultValue = Value(tokens.Take(), definition, true); + 276 [ + + ]: 17 : ValidateCycleTime(name, *definition.defaultValue); + 277 [ + - ]: 15 : tokens.End(); + 278 [ + - ]: 15 : defaultLines[name] = pending.lineNumber; + 279 [ + - ]: 15 : ApplyDefault(database, name, definition); + 280 : 15 : continue; + 281 : : } + 282 : 115 : AttributeAssignment assignment; + 283 [ + - ]: 115 : assignment.name = name; + 284 [ + - ]: 115 : Token value = tokens.Take(); + 285 [ + - + - : 115 : if (!value.quoted && IsScope(value.text)) { + + + + + ] + 286 [ + - ]: 34 : assignment.scope = ParseScope(value.text); + 287 [ + + + + ]: 34 : if (assignment.scope == AttributeScope::Frame || assignment.scope == AttributeScope::Signal) + 288 [ + - + + ]: 38 : ParseId(tokens.Word(), assignment); + 289 [ + + ]: 28 : if (assignment.scope != AttributeScope::Frame) + 290 [ + - ]: 7 : assignment.targetName = tokens.Word(); + 291 [ + - ]: 28 : value = tokens.Take(); + 292 : : } + 293 [ + + + - ]: 109 : if (assignment.scope != definition.scope) throw std::runtime_error("Attribute assignment scope differs from definition."); + 294 [ + + ]: 107 : assignment.value = Value(value, definition, false); + 295 [ + + ]: 19 : ValidateCycleTime(name, assignment.value); + 296 [ + - ]: 17 : tokens.End(); + 297 : : // Repeated explicit assignments use the last value, matching comments. + 298 [ + + + + ]: 17 : if (assignment.scope != AttributeScope::Node && assignment.scope != AttributeScope::Environment) + 299 [ + + + - : 15 : Target(database, assignment)[name] = assignment.value; + + - ] + 300 [ + - ]: 13 : database.attributeAssignments.push_back(assignment); + 301 [ + - ]: 13 : assignmentLines.push_back(pending.lineNumber); + 302 [ + + + + : 1406 : } catch (const std::exception &error) { + - + ] + 303 [ + - + - ]: 1158 : throw DbcDiagnosticError(DbcDiagnosticCode::InvalidAttribute, filePath, pending.lineNumber, error.what()); + 304 : 386 : } + 305 [ + + ]: 1303 : } + 306 : : } + 307 [ + + ]: 342 : for (FrameInfo &frame: database.frames) { + 308 [ + + ]: 191 : for (const AttributeMap::value_type &attribute: frame.attributes) { + 309 [ + - + + : 16 : if (attribute.first != "VFrameFormat" && attribute.first != "GenMsgCycleTime") continue; + + - + + + + + ] + 310 [ + - ]: 9 : std::size_t line = defaultLines[attribute.first]; + 311 [ + + ]: 37 : for (std::size_t index = 0U; index < database.attributeAssignments.size(); ++index) { + 312 : 28 : const AttributeAssignment &assignment = database.attributeAssignments[index]; + 313 [ + - ]: 40 : if (assignment.name == attribute.first && assignment.scope == AttributeScope::Frame && + 314 [ + + + + : 40 : assignment.canId == frame.canId && assignment.isExtended == frame.isExtended) + + + + + ] + 315 : 5 : line = assignmentLines[index]; + 316 : : } + 317 [ + - ]: 9 : const std::int64_t value = std::get<std::int64_t>(attribute.second); + 318 [ + - + + ]: 9 : if (attribute.first == "GenMsgCycleTime") { + 319 : 4 : frame.cycleTimeMs = static_cast<std::uint32_t>(value); + 320 : 4 : continue; + 321 : : } + 322 [ + - + - ]: 5 : frame.frameFormat = database.attributeDefinitions.at(attribute.first).enumValues[static_cast<std::size_t>(value)]; + 323 : 5 : const std::string &format = *frame.frameFormat; + 324 : 5 : std::string warning; + 325 [ + - + + : 5 : if (format != "StandardCAN" && format != "ExtendedCAN") + + - + + + + + ] + 326 [ + - + - ]: 2 : warning = "Unsupported VFrameFormat '" + format + "' is preserved; decoding may be incomplete."; + 327 [ + - + + ]: 3 : else if ((format == "ExtendedCAN") != frame.isExtended) + 328 [ + - + - ]: 1 : warning = "VFrameFormat '" + format + "' conflicts with the BO_ CAN ID; ID interpretation is unchanged."; + 329 [ + + ]: 5 : if (!warning.empty()) + 330 : 3 : diagnostics.push_back({DbcDiagnosticSeverity::Warning, DbcDiagnosticCode::UnsupportedAttribute, filePath, line, warning}); + 331 : 5 : } + 332 : : } + 333 [ + - + - : 938 : } + + - - - ] ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
Function Name  |
+
+ Hit count |
+
+
+
+
| DbcDecodeBuilder::Build(DbcDatabase const&) const | + +108 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcDecodeBuilder::Build(DbcDatabase const&) const | + +108 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : /** + 2 : : * @file dbc_decode_builder.cpp + 3 : : * @brief Conversion of parsed metadata to runtime definitions. + 4 : : * + 5 : : * Created: 2026-03-13 + 6 : : * Author: Deeaitch (Dim. Himro) + 7 : : * + 8 : : * Licensed under the MIT License. + 9 : : * See LICENSE file in the project root for full license text. + 10 : : */ + 11 : : + 12 : : #include "dbc_decode_builder.h" + 13 : : #include <utility> + 14 : : + 15 : 108 : DecodeDatabase DbcDecodeBuilder::Build(const DbcDatabase &source) const { + 16 : 108 : std::vector<DecodeFrame> frames; + 17 [ + - ]: 108 : frames.reserve(source.frames.size()); + 18 : : + 19 [ + + ]: 248 : for (const FrameInfo &sourceFrame: source.frames) { + 20 : 140 : DecodeFrame targetFrame; + 21 : : + 22 [ + - ]: 140 : targetFrame.attributes = sourceFrame.attributes; + 23 [ + - ]: 140 : targetFrame.frameFormat = sourceFrame.frameFormat; + 24 : 140 : targetFrame.cycleTimeMs = sourceFrame.cycleTimeMs; + 25 [ + - ]: 140 : targetFrame.name = sourceFrame.name; + 26 : 140 : targetFrame.canId = sourceFrame.canId; + 27 : 140 : targetFrame.isExtended = sourceFrame.isExtended; + 28 : 140 : targetFrame.dlc = sourceFrame.dlc; + 29 : 140 : targetFrame.pgn = sourceFrame.pgn; + 30 : 140 : targetFrame.hasPgn = sourceFrame.hasPgn; + 31 [ + - ]: 140 : targetFrame.transmitter = sourceFrame.transmitter; + 32 [ + - ]: 140 : targetFrame.comment = sourceFrame.comment; + 33 : : + 34 [ + - ]: 140 : targetFrame.signals.reserve(sourceFrame.signals.size()); + 35 [ + + ]: 313 : for (const SignalInfo &sourceSignal: sourceFrame.signals) { + 36 : 173 : DecodeSignal targetSignal; + 37 : : + 38 [ + - ]: 173 : targetSignal.attributes = sourceSignal.attributes; + 39 : 173 : targetSignal.multiplexing = sourceSignal.multiplexing; + 40 [ + - ]: 173 : targetSignal.name = sourceSignal.name; + 41 : 173 : targetSignal.startBit = sourceSignal.startBit; + 42 : 173 : targetSignal.length = sourceSignal.length; + 43 [ + + ]: 173 : targetSignal.byteOrder = sourceSignal.isLittleEndian ? ByteOrder::Intel : ByteOrder::Motorola; + 44 [ + + ]: 173 : targetSignal.valueType = sourceSignal.isSigned ? ValueType::Signed : ValueType::Unsigned; + 45 : 173 : targetSignal.factor = sourceSignal.factor; + 46 : 173 : targetSignal.offset = sourceSignal.offset; + 47 : 173 : targetSignal.minimum = sourceSignal.minimum; + 48 : 173 : targetSignal.maximum = sourceSignal.maximum; + 49 [ + - ]: 173 : targetSignal.unit = sourceSignal.unit; + 50 [ + - ]: 173 : targetSignal.receivers = sourceSignal.receivers; + 51 [ + - ]: 173 : targetSignal.comment = sourceSignal.comment; + 52 [ + - ]: 173 : targetSignal.valueDescriptions = sourceSignal.valueDescriptions; + 53 : : + 54 [ + - ]: 173 : targetFrame.signals.push_back(std::move(targetSignal)); + 55 : 173 : } + 56 : : + 57 [ + - ]: 140 : frames.push_back(std::move(targetFrame)); + 58 : 140 : } + 59 : : + 60 [ + + ]: 176 : return DecodeDatabase(frames); + 61 : 108 : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : /** + 2 : : * @file dbc_decoder.cpp + 3 : : * @brief CAN signal extraction and physical value conversion. + 4 : : * + 5 : : * Created: 2026-03-13 + 6 : : * Author: Deeaitch (Dim. Himro) + 7 : : * + 8 : : * Licensed under the MIT License. + 9 : : * See LICENSE file in the project root for full license text. + 10 : : */ + 11 : : + 12 : : #include "dbc_decoder.h" + 13 : : #include "j1939.h" + 14 : : #include "signal_layout.h" + 15 : : #include <cmath> + 16 : : #include <stdexcept> + 17 : : #include <unordered_set> + 18 : : #include <utility> + 19 : : + 20 : 32 : std::shared_ptr<const DecodeFrame> DbcDecoder::FindFrame(const DecodeDatabase &database, + 21 : : std::uint32_t canId, + 22 : : bool isExtended) const { + 23 [ + - ]: 32 : return ResolveFrame(database, canId, isExtended).definition; + 24 : : } + 25 : : + 26 : 6440 : PgnLookupResult DbcDecoder::ResolveFrame(const DecodeDatabase &database, + 27 : : std::uint32_t canId, bool isExtended) { + 28 [ + - ]: 6440 : const std::shared_ptr<const DecodeFrame> exact = database.FindFrame(FrameKey(canId, isExtended)); + 29 [ + + ]: 6440 : if (exact) + 30 : 6335 : return {exact, false}; + 31 [ + + + + ]: 105 : if (!isExtended || canId > 0x1FFFFFFFU) + 32 : 25 : return {}; + 33 [ + - ]: 80 : return database.FindFrameByPgn(ExtractJ1939Pgn(canId)); + 34 : 6440 : } + 35 : : + 36 : 6396 : DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database, + 37 : : const RawCanFrame &frame) const { + 38 : 6396 : return DecodeImpl(database, frame, nullptr); + 39 : : } + 40 : : + 41 : 12 : DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database, + 42 : : const RawCanFrame &frame, + 43 : : const std::vector<SignalKey> &selection) const { + 44 : 12 : return DecodeImpl(database, frame, &selection); + 45 : : } + 46 : : + 47 : 6408 : DecodedFrameValue DbcDecoder::DecodeImpl(const DecodeDatabase &database, + 48 : : const RawCanFrame &frame, + 49 : : const std::vector<SignalKey> *selection) const { + 50 : 6408 : DecodedFrameValue result; + 51 : 6408 : result.key = FrameKey(frame.canId, frame.isExtended); + 52 [ + - ]: 6408 : const PgnLookupResult match = ResolveFrame(database, frame.canId, frame.isExtended); + 53 [ + + ]: 6408 : if (match.ambiguous) { + 54 : 8 : result.status = FrameDecodeStatus::AmbiguousFrame; + 55 : 8 : return result; + 56 : : } + 57 : 6400 : const std::shared_ptr<const DecodeFrame> definition = match.definition; + 58 [ + + ]: 6400 : if (definition == nullptr) + 59 : 55 : return result; + 60 : 6345 : result.key = definition->GetKey(); + 61 : : + 62 : 6345 : std::vector<const DecodeSignal *> selected; + 63 [ + + ]: 6345 : if (selection != nullptr) { + 64 [ + - ]: 8 : selected.reserve(selection->size()); + 65 : 8 : std::unordered_set<SignalKey, SignalKeyHasher> keys; + 66 [ + + ]: 12 : for (const SignalKey &key: *selection) { + 67 [ + + ]: 8 : if (!(key.frame == result.key)) + 68 [ + - + - ]: 4 : throw std::invalid_argument("Selected signal belongs to another frame: " + key.name); + 69 [ + - - + ]: 4 : if (!keys.insert(key).second) + 70 [ # # # # ]: 0 : throw std::invalid_argument("Duplicate selected signal: " + key.name); + 71 [ + - ]: 4 : const std::shared_ptr<const DecodeSignal> signal = database.FindSignal(key); + 72 [ - + ]: 4 : if (!signal) + 73 [ # # # # ]: 0 : throw std::invalid_argument("Unknown selected signal: " + key.name); + 74 [ + - ]: 4 : selected.push_back(signal.get()); + 75 : 4 : } + 76 : 8 : } + 77 : : + 78 : 6341 : result.definition = definition; + 79 : 6341 : result.valid = true; + 80 : 6341 : result.status = frame.data.size() < definition->dlc + 81 [ + + ]: 6341 : ? FrameDecodeStatus::InsufficientPayload + 82 : : : FrameDecodeStatus::Valid; + 83 : : + 84 [ + - ]: 6341 : const SelectorState selector = ReadSelector(*definition, frame); + 85 [ + + ]: 6341 : const std::size_t count = selection != nullptr ? selected.size() : definition->signals.size(); + 86 [ + - ]: 6341 : result.signals.reserve(count); + 87 [ + + ]: 12716 : for (std::size_t index = 0U; index < count; ++index) { + 88 [ + + ]: 6375 : const DecodeSignal &signal = selection != nullptr ? *selected[index] : definition->signals[index]; + 89 [ + - ]: 6375 : DecodedSignalValue decoded = DecodeOneSignal(signal, definition->dlc, frame, selector); + 90 [ + + + + ]: 6375 : if (!decoded.valid && decoded.status != SignalDecodeStatus::Inactive && + 91 [ + + ]: 31 : result.status == FrameDecodeStatus::Valid) + 92 : 5 : result.status = FrameDecodeStatus::SignalErrors; + 93 : 6375 : decoded.definition = std::shared_ptr<const DecodeSignal>(definition, &signal); + 94 [ + - ]: 6375 : decoded.key = SignalKey(result.key, signal.name); + 95 [ + - ]: 6375 : result.signals.push_back(std::move(decoded)); + 96 : 6375 : } + 97 : : + 98 : 6341 : return result; + 99 : 6420 : } + 100 : : + 101 : 6396 : bool DbcDecoder::IsValidDefinition(const DecodeSignal &signal, std::uint8_t dlc) { + 102 [ + + + - ]: 6396 : if ((signal.byteOrder != ByteOrder::Intel && signal.byteOrder != ByteOrder::Motorola) || + 103 [ + + + - ]: 6396 : (signal.valueType != ValueType::Unsigned && signal.valueType != ValueType::Signed) || + 104 [ + + ]: 6396 : (signal.multiplexing.role != MultiplexRole::Unconditional && + 105 [ + + ]: 71 : signal.multiplexing.role != MultiplexRole::Selector && + 106 [ - + ]: 29 : signal.multiplexing.role != MultiplexRole::Branch)) + 107 : 0 : return false; + 108 : : + 109 : 6396 : return IsValidSignalLayout(signal.startBit, signal.length, + 110 : 6396 : signal.byteOrder == ByteOrder::Intel, dlc); + 111 : : } + 112 : : + 113 : 6341 : DbcDecoder::SelectorState DbcDecoder::ReadSelector(const DecodeFrame &definition, + 114 : : const RawCanFrame &frame) { + 115 : 6341 : SelectorState selector; + 116 : 6341 : std::size_t count = 0U; + 117 [ + + ]: 12716 : for (const DecodeSignal &signal: definition.signals) { + 118 [ + + ]: 6375 : if (signal.multiplexing.role == MultiplexRole::Selector) { + 119 : 21 : selector.definition = &signal; + 120 : 21 : ++count; + 121 : : } + 122 : : } + 123 [ + + ]: 6341 : if (count != 1U) + 124 : 6320 : return selector; + 125 : : + 126 : 21 : const DecodeSignal &signal = *selector.definition; + 127 [ + - ]: 42 : selector.valid = signal.valueType == ValueType::Unsigned && + 128 [ + - ]: 21 : IsValidDefinition(signal, definition.dlc); + 129 [ + - + + ]: 21 : selector.available = selector.valid && ExtractUnsigned(frame.data, signal, selector.value); + 130 : 21 : return selector; + 131 : : } + 132 : : + 133 : 6375 : DecodedSignalValue DbcDecoder::DecodeOneSignal(const DecodeSignal &signal, + 134 : : std::uint8_t dlc, + 135 : : const RawCanFrame &frame, + 136 : : const SelectorState &selector) { + 137 : 6375 : DecodedSignalValue decoded; + 138 : 6375 : std::uint64_t unsignedValue = 0U; + 139 : : + 140 [ + - + - : 12750 : if (!IsValidDefinition(signal, dlc) || + - + ] + 141 [ + + - + ]: 6375 : (signal.multiplexing.role != MultiplexRole::Unconditional && !selector.valid)) { + 142 : 0 : return decoded; + 143 : : } + 144 [ + + ]: 6375 : if (signal.multiplexing.role == MultiplexRole::Branch) { + 145 [ + + - + ]: 29 : if (selector.definition->length < 64U && signal.multiplexing.value >= (std::uint64_t(1U) << selector.definition->length)) { + 146 : 0 : return decoded; + 147 : : } + 148 [ + + ]: 29 : if (!selector.available) { + 149 : 3 : decoded.status = SignalDecodeStatus::SelectorUnavailable; + 150 : 3 : return decoded; + 151 : : } + 152 [ + + ]: 26 : if (signal.multiplexing.value != selector.value) { + 153 : 13 : decoded.status = SignalDecodeStatus::Inactive; + 154 : 13 : return decoded; + 155 : : } + 156 : : } + 157 [ + - + + ]: 6359 : if (!ExtractUnsigned(frame.data, signal, unsignedValue)) { + 158 : 23 : decoded.status = SignalDecodeStatus::InsufficientPayload; + 159 : 23 : return decoded; + 160 : : } + 161 : : + 162 [ + + ]: 6336 : if (signal.valueType == ValueType::Signed) + 163 [ + - ]: 81 : decoded.rawValue = SignExtend(unsignedValue, signal.length); + 164 : : else + 165 : 6255 : decoded.rawValue = unsignedValue; + 166 : : + 167 : : double numericValue; + 168 [ + + ]: 6336 : if (const std::int64_t *signedValue = std::get_if<std::int64_t>(&decoded.rawValue)) + 169 : 81 : numericValue = static_cast<double>(*signedValue); + 170 : : else + 171 [ + - ]: 6255 : numericValue = static_cast<double>(std::get<std::uint64_t>(decoded.rawValue)); + 172 : 6336 : decoded.physicalValue = numericValue * signal.factor + signal.offset; + 173 [ + + ]: 6336 : if (!std::isfinite(decoded.physicalValue)) { + 174 : 5 : decoded.status = SignalDecodeStatus::PhysicalConversionFailed; + 175 : 5 : return decoded; + 176 : : } + 177 : 6331 : decoded.valid = true; + 178 : 6331 : decoded.status = SignalDecodeStatus::Valid; + 179 : : + 180 : 6331 : return decoded; + 181 : 0 : } + 182 : : + 183 : 6380 : bool DbcDecoder::ExtractUnsigned(const std::vector<std::uint8_t> &data, + 184 : : const DecodeSignal &signal, + 185 : : std::uint64_t &value) { + 186 [ + - - + ]: 6380 : if ((signal.length == 0U) || (signal.length > 64U)) + 187 : 0 : return false; + 188 : : + 189 [ + + ]: 6380 : if (signal.byteOrder == ByteOrder::Intel) + 190 : 3242 : return ExtractIntel(data, signal.startBit, signal.length, value); + 191 : : + 192 : 3138 : return ExtractMotorola(data, signal.startBit, signal.length, value); + 193 : : } + 194 : : + 195 : 3242 : bool DbcDecoder::ExtractIntel(const std::vector<std::uint8_t> &data, + 196 : : std::uint32_t startBit, + 197 : : std::uint32_t length, + 198 : : std::uint64_t &value) { + 199 : 3242 : value = 0U; + 200 : : + 201 [ + + ]: 105558 : for (std::uint32_t bitIndex = 0U; bitIndex < length; ++bitIndex) { + 202 : 102334 : const std::uint64_t absoluteBit = std::uint64_t(startBit) + bitIndex; + 203 : 102334 : const std::uint64_t byteIndex = absoluteBit / 8U; + 204 : 102334 : const std::uint32_t bitInByte = absoluteBit % 8U; + 205 : : + 206 [ + + ]: 102334 : if (byteIndex >= data.size()) + 207 : 18 : return false; + 208 : : + 209 : : const std::uint64_t bitValue = + 210 : 102316 : (static_cast<std::uint64_t>((data[byteIndex] >> bitInByte) & 0x01U) << bitIndex); + 211 : : + 212 : 102316 : value |= bitValue; + 213 : : } + 214 : : + 215 : 3224 : return true; + 216 : : } + 217 : : + 218 : 3138 : bool DbcDecoder::ExtractMotorola(const std::vector<std::uint8_t> &data, + 219 : : std::uint32_t startBit, + 220 : : std::uint32_t length, + 221 : : std::uint64_t &value) { + 222 : : /* + 223 : : * DBC Motorola bit numbering: + 224 : : * - startBit points to the most significant bit of the signal + 225 : : * - inside a byte, bit numbering goes 7..0 + 226 : : * - crossing byte boundary moves to the next byte, bit 7 + 227 : : * Example: a signal starting at 7 follows 7..0, 15..8, 23..16. + 228 : : */ + 229 : : + 230 : 3138 : value = 0U; + 231 : : + 232 : 3138 : std::size_t byteIndex = startBit / 8U; + 233 : 3138 : std::uint32_t bitInByte = startBit % 8U; + 234 : : + 235 [ + + ]: 104732 : for (std::uint32_t bitIndex = 0U; bitIndex < length; ++bitIndex) { + 236 [ + + ]: 101601 : if (byteIndex >= data.size()) + 237 : 7 : return false; + 238 : : + 239 : 101594 : value <<= 1U; + 240 : 101594 : value |= static_cast<std::uint64_t>((data[byteIndex] >> bitInByte) & 0x01U); + 241 : : + 242 [ + + ]: 101594 : if (bitInByte == 0U) { + 243 : 12688 : ++byteIndex; + 244 : 12688 : bitInByte = 7U; + 245 : : } else + 246 : 88906 : --bitInByte; + 247 : : } + 248 : : + 249 : 3131 : return true; + 250 : : } + 251 : : + 252 : 81 : std::int64_t DbcDecoder::SignExtend(std::uint64_t value, std::uint32_t bitLength) { + 253 [ + - - + ]: 81 : if ((bitLength == 0U) || (bitLength > 64U)) + 254 : 0 : return 0; + 255 : : + 256 : 81 : const std::uint64_t signMask = std::uint64_t(1U) << (bitLength - 1U); + 257 : 81 : const std::uint64_t valueMask = (bitLength == 64U) + 258 [ + + ]: 81 : ? ~std::uint64_t(0U) + 259 : 68 : : (std::uint64_t(1U) << bitLength) - 1U; + 260 : 81 : value &= valueMask; + 261 : : + 262 [ + + ]: 81 : if ((value & signMask) == 0U) + 263 : 41 : return static_cast<std::int64_t>(value); + 264 : : + 265 : : // The complemented magnitude fits int64_t, including for INT64_MIN. + 266 : 40 : return -1 - static_cast<std::int64_t>((~value) & valueMask); + 267 : : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DecodedSignalValue::GetValueDescription[abi:cxx11]() const | + +79 | + + + +
| RawCanFrame::RawCanFrame() | + +2220 | + + + +
| DecodedSignalValue::DecodedSignalValue() | + +6380 | + + + +
| DecodedFrameValue::DecodedFrameValue() | + +6409 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DecodedFrameValue::DecodedFrameValue() | + +6409 | + + + +
| DecodedSignalValue::DecodedSignalValue() | + +6380 | + + + +
| DecodedSignalValue::GetValueDescription[abi:cxx11]() const | + +79 | + + + +
| RawCanFrame::RawCanFrame() | + +2220 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : /** + 2 : : * @file dbc_decoder.h + 3 : : * @brief CAN frame decoding API and result types. + 4 : : * + 5 : : * Created: 2026-03-13 + 6 : : * Author: Deeaitch (Dim. Himro) + 7 : : * + 8 : : * Licensed under the MIT License. + 9 : : * See LICENSE file in the project root for full license text. + 10 : : */ + 11 : : + 12 : : #ifndef DBC_DECODER_H + 13 : : #define DBC_DECODER_H + 14 : : + 15 : : #include <cstdint> + 16 : : #include <variant> + 17 : : #include <vector> + 18 : : + 19 : : #include "decode_database.h" + 20 : : + 21 : : /** + 22 : : * @brief Raw CAN frame used for runtime or trace decoding. + 23 : : */ + 24 : : struct RawCanFrame { + 25 : : std::uint32_t canId = 0U; /**< Normalized CAN ID. */ + 26 : : bool isExtended = false; /**< true for extended frame. */ + 27 : : std::vector<std::uint8_t> data; /**< Payload bytes. */ + 28 : : + 29 : 2220 : RawCanFrame() = default; + 30 : : }; + 31 : : + 32 : : /** @brief Outcome of signal extraction and physical conversion. */ + 33 : : enum class SignalDecodeStatus { + 34 : : InvalidDefinition, + 35 : : InsufficientPayload, + 36 : : SelectorUnavailable, + 37 : : Inactive, + 38 : : Valid, + 39 : : PhysicalConversionFailed + 40 : : }; + 41 : : + 42 : : /** Frame summary: short payload takes precedence over individual signal errors. */ + 43 : : enum class FrameDecodeStatus { + 44 : : UnknownFrame, + 45 : : InsufficientPayload, + 46 : : SignalErrors, + 47 : : Valid, + 48 : : AmbiguousFrame + 49 : : }; + 50 : : + 51 : : /** + 52 : : * @brief One decoded signal value. + 53 : : */ + 54 : : struct DecodedSignalValue { + 55 : : std::shared_ptr<const DecodeSignal> definition; /**< Owning immutable definition. */ + 56 : : SignalKey key; /**< Stable application identifier. */ + 57 : : RawSignalValue rawValue = std::uint64_t(0U); /**< Exact raw value for Valid or PhysicalConversionFailed. */ + 58 : : double physicalValue = 0.0; /**< Conversion result, possibly NaN/Inf on failure. */ + 59 : : bool valid = false; /**< true if decoding succeeded. */ + 60 : : SignalDecodeStatus status = SignalDecodeStatus::InvalidDefinition; /**< Detailed signal outcome. */ + 61 : : + 62 : : /** Lookup using the raw integer; nullptr for invalid or unmapped values. */ + 63 : 79 : const std::string *GetValueDescription() const { + 64 [ + + + - ]: 79 : return valid && definition ? FindValueDescription(definition->valueDescriptions, rawValue) : nullptr; + 65 : : } + 66 : : + 67 : 6380 : DecodedSignalValue() = default; + 68 : : }; + 69 : : + 70 : : /** + 71 : : * @brief Fully decoded frame. + 72 : : */ + 73 : : struct DecodedFrameValue { + 74 : : std::shared_ptr<const DecodeFrame> definition; /**< Owning immutable definition. */ + 75 : : FrameKey key; /**< Matched definition key; received key if unmatched. */ + 76 : : std::vector<DecodedSignalValue> signals; /**< Decoded signal values. */ + 77 : : bool valid = false; /**< true if frame was matched. */ + 78 : : FrameDecodeStatus status = FrameDecodeStatus::UnknownFrame; /**< Inspect signals for individual failures. */ + 79 : : + 80 : 6409 : DecodedFrameValue() = default; + 81 : : }; + 82 : : + 83 : : /** + 84 : : * @brief Runtime CAN decoder using prebuilt decode database. + 85 : : */ + 86 : : class DbcDecoder { + 87 : : public: + 88 : : /** + 89 : : * @brief Find exact CAN ID first, then unique PGN among explicitly J1939 definitions. + 90 : : * @param database Runtime decode database. + 91 : : * @param canId Normalized CAN ID. + 92 : : * @param isExtended true for extended frame. + 93 : : * @return Owning immutable handle, or nullptr for missing/ambiguous matches. Safe across reload. + 94 : : */ + 95 : : std::shared_ptr<const DecodeFrame> FindFrame(const DecodeDatabase &database, + 96 : : std::uint32_t canId, + 97 : : bool isExtended) const; + 98 : : + 99 : : /** + 100 : : * @brief Decode one raw CAN frame. + 101 : : * @param database Runtime decode database. + 102 : : * @param frame Raw CAN frame. + 103 : : * Short payloads decode available signals; bytes beyond declared DLC are ignored. + 104 : : * @return Decoded frame value. + 105 : : */ + 106 : : DecodedFrameValue Decode(const DecodeDatabase &database, + 107 : : const RawCanFrame &frame) const; + 108 : : + 109 : : /** + 110 : : * @brief Decode selected signals in selection order using stable keys. + 111 : : * An empty selection returns no signals. Multiplex selectors are read internally. + 112 : : * Frame status summarizes selected signals; short payload still takes precedence. + 113 : : * Unknown/ambiguous frames return before checking the selection. + 114 : : * For PGN matches, selection keys must belong to the matched DBC definition. + 115 : : * @throws std::invalid_argument for a foreign frame key, unknown signal, or duplicate key. + 116 : : */ + 117 : : DecodedFrameValue Decode(const DecodeDatabase &database, + 118 : : const RawCanFrame &frame, + 119 : : const std::vector<SignalKey> &selection) const; + 120 : : + 121 : : private: + 122 : : static PgnLookupResult ResolveFrame(const DecodeDatabase &database, + 123 : : std::uint32_t canId, bool isExtended); + 124 : : + 125 : : DecodedFrameValue DecodeImpl(const DecodeDatabase &database, + 126 : : const RawCanFrame &frame, + 127 : : const std::vector<SignalKey> *selection) const; + 128 : : + 129 : : static bool IsValidDefinition(const DecodeSignal &signal, std::uint8_t dlc); + 130 : : + 131 : : struct SelectorState { + 132 : : const DecodeSignal *definition = nullptr; + 133 : : bool valid = false; + 134 : : bool available = false; + 135 : : std::uint64_t value = 0U; + 136 : : }; + 137 : : + 138 : : static SelectorState ReadSelector(const DecodeFrame &definition, const RawCanFrame &frame); + 139 : : static DecodedSignalValue DecodeOneSignal(const DecodeSignal &signal, + 140 : : std::uint8_t dlc, + 141 : : const RawCanFrame &frame, + 142 : : const SelectorState &selector); + 143 : : + 144 : : static bool ExtractUnsigned(const std::vector<std::uint8_t> &data, + 145 : : const DecodeSignal &signal, + 146 : : std::uint64_t &value); + 147 : : + 148 : : static bool ExtractIntel(const std::vector<std::uint8_t> &data, + 149 : : std::uint32_t startBit, + 150 : : std::uint32_t length, + 151 : : std::uint64_t &value); + 152 : : + 153 : : static bool ExtractMotorola(const std::vector<std::uint8_t> &data, + 154 : : std::uint32_t startBit, + 155 : : std::uint32_t length, + 156 : : std::uint64_t &value); + 157 : : + 158 : : static std::int64_t SignExtend(std::uint64_t value, std::uint32_t bitLength); + 159 : : }; + 160 : : + 161 : : #endif /* DBC_DECODER_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcParseResult::HasErrors() const | + +293 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcParseResult::HasErrors() const | + +293 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #ifndef DBC_DIAGNOSTIC_H + 3 : : #define DBC_DIAGNOSTIC_H + 4 : : + 5 : : #include "dbc_database.h" + 6 : : #include <cstddef> + 7 : : #include <string> + 8 : : #include <vector> + 9 : : + 10 : : /** @brief Warning or fatal parse error. */ + 11 : : enum class DbcDiagnosticSeverity { + 12 : : Warning, + 13 : : Error + 14 : : }; + 15 : : + 16 : : /** Stable categories; messages provide the details. */ + 17 : : enum class DbcDiagnosticCode { + 18 : : FileOpenError, + 19 : : FileReadError, + 20 : : InvalidStatement, + 21 : : InvalidValueDescription, + 22 : : InvalidMultiplexing, + 23 : : UnsupportedStatement, + 24 : : InvalidAttribute, + 25 : : UnsupportedAttribute + 26 : : }; + 27 : : + 28 : : /** @brief Diagnostic message and physical source location. */ + 29 : : struct DbcDiagnostic { + 30 : : DbcDiagnosticSeverity severity; /**< Message severity. */ + 31 : : DbcDiagnosticCode code; /**< Stable diagnostic category. */ + 32 : : std::string filePath; /**< Input file path. */ + 33 : : std::size_t lineNumber; /**< One-based physical line; zero for file-level errors. */ + 34 : : std::string message; /**< Human-readable diagnostic details. */ + 35 : : }; + 36 : : + 37 : : /** @brief Parsed database and diagnostics; the database is empty on error. */ + 38 : : struct DbcParseResult { + 39 : : DbcDatabase database; /**< Parsed content, published only on success. */ + 40 : : std::vector<DbcDiagnostic> diagnostics; /**< Warnings and the first error, if any. */ + 41 : : + 42 : : /** @brief Return whether any diagnostic has error severity. */ + 43 : 293 : bool HasErrors() const { + 44 [ + + ]: 327 : for (const DbcDiagnostic &diagnostic: diagnostics) { + 45 [ + + ]: 283 : if (diagnostic.severity == DbcDiagnosticSeverity::Error) + 46 : 249 : return true; + 47 : : } + 48 : 44 : return false; + 49 : : } + 50 : : }; + 51 : : + 52 : : #endif /* DBC_DIAGNOSTIC_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : /** + 2 : : * @file dbc_parser.cpp + 3 : : * @brief DBC file reading and diagnostic collection. + 4 : : * + 5 : : * Created: 2026-03-13 + 6 : : * Author: Deeaitch (Dim. Himro) + 7 : : * + 8 : : * Licensed under the MIT License. + 9 : : * See LICENSE file in the project root for full license text. + 10 : : */ + 11 : : + 12 : : #include "dbc_parser.h" + 13 : : #include "dbc_statement_handler.h" + 14 : : + 15 : : #include "text_utils.h" + 16 : : #include <fstream> + 17 : : #include <sstream> + 18 : : #include <stdexcept> + 19 : : #include <utility> + 20 : : + 21 : : namespace { + 22 : : // Read through the closing unescaped quote, preserving comment whitespace. + 23 : 140 : void ReadCommentLines(std::ifstream &input, std::string &statement, + 24 : : std::size_t &lineNumber) { + 25 : 140 : bool inQuote = false; + 26 : 140 : bool escaped = false; + 27 [ + - ]: 140 : std::string part = statement; + 28 : : for (;;) { + 29 [ + + ]: 3677 : for (const char character: part) { + 30 [ + + ]: 3662 : if (escaped) { + 31 : 5 : escaped = false; + 32 [ + + + + ]: 3657 : } else if (inQuote && character == '\\') { + 33 : 7 : escaped = true; + 34 [ + + ]: 3650 : } else if (character == '"') { + 35 [ + + ]: 268 : if (inQuote) + 36 : 132 : return; + 37 : 136 : inQuote = true; + 38 : : } + 39 : : } + 40 [ + + + - : 15 : if (!inQuote || !std::getline(input, part)) + + - + + + + + ] + 41 : 8 : return; + 42 : 7 : ++lineNumber; + 43 [ + - + + : 7 : if (!part.empty() && part.back() == '\r') + + + ] + 44 : 2 : part.pop_back(); + 45 [ + - ]: 7 : statement += '\n'; + 46 [ + - ]: 7 : statement += part; + 47 : : // A physical newline cannot escape the next line's first character. + 48 : 7 : escaped = false; + 49 : 7 : } + 50 : 140 : } + 51 : : + 52 : 349 : DbcDiagnosticCode StatementErrorCode(const std::string &keyword) { + 53 [ + + ]: 349 : if (keyword == "SG_MUL_VAL_") + 54 : 4 : return DbcDiagnosticCode::UnsupportedStatement; + 55 [ + + ]: 345 : if (keyword == "VAL_") + 56 : 25 : return DbcDiagnosticCode::InvalidValueDescription; + 57 : 320 : return DbcDiagnosticCode::InvalidStatement; + 58 : : } + 59 : : } + 60 : : + 61 : 656 : DbcDatabase DbcParser::ParseFile(const std::string &filePath) const { + 62 [ + - ]: 656 : DbcParseResult result = ParseFileWithDiagnostics(filePath); + 63 [ + + ]: 662 : for (const DbcDiagnostic &diagnostic : result.diagnostics) { + 64 [ + + ]: 545 : if (diagnostic.severity == DbcDiagnosticSeverity::Error) { + 65 [ + + ]: 539 : if (diagnostic.lineNumber == 0U) + 66 [ + - ]: 3 : throw std::runtime_error(diagnostic.message); + 67 [ + - ]: 1072 : throw std::runtime_error(diagnostic.filePath + ":" + + 68 [ + - + - : 1608 : std::to_string(diagnostic.lineNumber) + ": " + diagnostic.message); + + - + - + + - ] + 69 : : } + 70 : : } + 71 : 234 : return std::move(result.database); + 72 : 656 : } + 73 : : + 74 : 951 : DbcParseResult DbcParser::ParseFileWithDiagnostics(const std::string &filePath) const { + 75 : 951 : DbcParseResult result; + 76 [ + - ]: 951 : std::ifstream input(filePath.c_str()); + 77 [ + + ]: 951 : if (!input.is_open()) { + 78 : 3 : result.diagnostics.push_back({DbcDiagnosticSeverity::Error, + 79 : : DbcDiagnosticCode::FileOpenError, filePath, 0U, + 80 : : "Failed to open DBC file: " + filePath}); + 81 : 3 : return result; + 82 : : } + 83 : : + 84 : 948 : DbcDatabase database; + 85 : 948 : DbcParseContext context{database, nullptr}; + 86 : 948 : context.enableJ1939 = options.enableJ1939; + 87 [ + - ]: 948 : const DbcStatementDispatcher dispatcher; + 88 : 948 : bool inNamespace = false; + 89 : 948 : std::size_t lineNumber = 0U; + 90 : 948 : std::string line; + 91 [ + - + - : 3097 : while (std::getline(input, line)) { + + + ] + 92 : 2498 : ++lineNumber; + 93 [ + + + + : 2498 : if (!line.empty() && line.back() == '\r') + + + ] + 94 : 19 : line.pop_back(); + 95 [ + - ]: 2498 : const std::string rawLine = line; + 96 : 2498 : const std::size_t statementLine = lineNumber; + 97 [ + - ]: 2498 : line = dbc_detail::TrimText(line); + 98 [ + + ]: 2498 : if (line.empty()) + 99 : 342 : continue; + 100 : : + 101 [ + - ]: 2156 : std::istringstream tokens(line); + 102 : 2156 : std::string keyword; + 103 : 2156 : std::string argument; + 104 [ + - ]: 2156 : tokens >> keyword; + 105 [ + - + - ]: 2156 : const bool hasArgument = static_cast<bool>(tokens >> argument); + 106 [ + + + - : 44 : if (inNamespace && !hasArgument && keyword != "BO_" && keyword != "SG_" && + + + + - + + + ] + 107 [ + - + + : 36 : keyword != "BS_" && keyword != "BS_:" && + + - + + ] + 108 [ + + + - : 2200 : keyword != "BU_" && keyword != "BU_:") + + + + - + + + + + ] + 109 : 29 : continue; // NS_ lists syntax symbols; BO_, SG_, BS_ and BU_ end the list. + 110 [ + - + + : 2127 : inNamespace = keyword == "NS_" || keyword == "NS_:"; + + - + + ] + 111 : : + 112 [ + - + + ]: 2127 : if (keyword == "CM_") { + 113 [ + - ]: 140 : line = rawLine; + 114 [ + - ]: 140 : ReadCommentLines(input, line, lineNumber); + 115 : : } + 116 : : + 117 : : try { + 118 : 2127 : context.lineNumber = statementLine; + 119 [ + + + + ]: 2127 : if (!dispatcher.Dispatch(line, context)) { + 120 : 37 : result.diagnostics.push_back({DbcDiagnosticSeverity::Warning, + 121 : : DbcDiagnosticCode::UnsupportedStatement, + 122 : : filePath, statementLine, + 123 : 37 : "Unsupported statement '" + keyword + + 124 : : "' is ignored; decoding or metadata may be incomplete."}); + 125 : : } + 126 [ - + ]: 349 : } catch (const std::exception &error) { + 127 : 349 : result.diagnostics.push_back({DbcDiagnosticSeverity::Error, + 128 : 698 : StatementErrorCode(keyword), filePath, + 129 : 0 : statementLine, error.what()}); + 130 : 349 : return result; + 131 : 349 : } + 132 [ + + + + : 3632 : } + + + + + + + + + + ] + 133 : : + 134 [ + - + + : 599 : if (input.bad() || !input.eof()) { + + - - + + + + ] + 135 : 2 : result.diagnostics.push_back({DbcDiagnosticSeverity::Error, + 136 : : DbcDiagnosticCode::FileReadError, filePath, 0U, + 137 : : "Failed to read DBC file: " + filePath}); + 138 : 2 : return result; + 139 : : } + 140 : : + 141 : : try { + 142 [ + + ]: 597 : context.ResolveComments(filePath); + 143 [ + + ]: 587 : context.ResolveValueDescriptions(filePath); + 144 [ + + ]: 576 : context.ValidateMultiplexing(filePath); + 145 [ + + ]: 549 : context.ResolveAttributes(filePath, result.diagnostics); + 146 [ - + ]: 434 : } catch (const DbcDiagnosticError &error) { + 147 [ + - ]: 434 : result.diagnostics.push_back(error.diagnostic); + 148 : 434 : return result; + 149 [ + - ]: 434 : } + 150 : 163 : result.database = std::move(database); + 151 : 163 : return result; + 152 [ + - + - : 1691 : } + + - + - + + - + - + - + + - + - + + - - - - - + + - + - + + - + - - - + - - ] ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcParser::DbcParser(DbcParserOptions) | + +930 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcParser::DbcParser(DbcParserOptions) | + +930 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
+Line data Source code+ + 1 : /** + 2 : * @file dbc_parser.h + 3 : * @brief DBC file parser and interpretation options. + 4 : * + 5 : * Created: 2026-03-13 + 6 : * Author: Deeaitch (Dim. Himro) + 7 : * + 8 : * Licensed under the MIT License. + 9 : * See LICENSE file in the project root for full license text. + 10 : */ + 11 : + 12 : #ifndef DBC_PARSER_H + 13 : #define DBC_PARSER_H + 14 : + 15 : #include <string> + 16 : + 17 : #include "dbc_diagnostic.h" + 18 : + 19 : /** Explicit interpretation applied to extended frames in this file. */ + 20 : struct DbcParserOptions { + 21 : bool enableJ1939 = false; /**< Derive J1939 PGNs from extended CAN IDs. */ + 22 : }; + 23 : + 24 : /** + 25 : * @brief Minimal DBC parser. + 26 : * + 27 : * Supports: + 28 : * - BO_ + 29 : * - SG_ + 30 : * - CM_ BO_ + 31 : * - CM_ SG_ + 32 : * - basic M / mN multiplexing + 33 : * - VAL_ signal value descriptions + 34 : * - BA_DEF_, BA_DEF_DEF_, BA_ typed attributes, frame format and cycle time + 35 : * + 36 : * Frame/signal comments support multiline quoted text and deferred references. + 37 : * + 38 : * Reports unsupported statements as warnings, except SG_MUL_VAL_ which is + 39 : * an error. VERSION, NS_, BS_, BU_ and NS_ symbol declarations stay quiet. + 40 : */ + 41 : class DbcParser { + 42 : public: + 43 : /** @brief Create a parser with explicit extended-frame interpretation options. */ + 44 930 : explicit DbcParser(DbcParserOptions options = {}) : options(options) {} + 45 : + 46 : /** + 47 : * @brief Parse DBC file. + 48 : * @param filePath Path to input file. + 49 : * @return Parsed database. + 50 : * @throws std::runtime_error on file or parse errors. + 51 : * Line parse errors include the file path and one-based line number. + 52 : * Duplicate normalized CAN IDs of the same frame type and duplicate signal + 53 : * names within a frame are rejected at the repeated definition's line. + 54 : */ + 55 : DbcDatabase ParseFile(const std::string &filePath) const; + 56 : + 57 : /** + 58 : * @brief Parse with warnings and a structured first error instead of throwing. + 59 : * @return Valid database with diagnostics; empty database on error. + 60 : * File errors use line zero; statement errors use physical one-based lines. + 61 : * Warnings indicate ignored syntax and possible incomplete decoding. + 62 : */ + 63 : DbcParseResult ParseFileWithDiagnostics(const std::string &filePath) const; + 64 : + 65 : private: + 66 : DbcParserOptions options; + 67 : }; + 68 : + 69 : #endif /* DBC_PARSER_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #include "dbc_statement_handler.h" + 3 : : #include "j1939.h" + 4 : : #include "text_utils.h" + 5 : : #include "signal_layout.h" + 6 : : #include <charconv> + 7 : : #include <cmath> + 8 : : #include <limits> + 9 : : #include <regex> + 10 : : #include <sstream> + 11 : : #include <stdexcept> + 12 : : + 13 : : namespace { + 14 : 2466 : std::uint32_t ParseDecimal(const std::string &text, + 15 : : std::uint32_t maximum, + 16 : : const char *field) { + 17 : 2466 : std::uint32_t value = 0U; + 18 [ + - ]: 2466 : const std::from_chars_result parsed = std::from_chars(text.data(), text.data() + text.size(), value); + 19 [ + + ]: 4932 : if (text.empty() || parsed.ec != std::errc() || + 20 [ + - + + : 4932 : parsed.ptr != text.data() + text.size() || value > maximum) + + + + + ] + 21 [ + - + - : 174 : throw std::runtime_error(std::string("Invalid ") + field + ": " + text); + + - + - + + - ] + 22 : 2408 : return value; + 23 : : } + 24 : : + 25 : 784 : std::uint32_t ParseCanId(const std::string &text) { + 26 : 784 : const std::uint32_t rawId = ParseDecimal( + 27 : : text, std::numeric_limits<std::uint32_t>::max(), "CAN ID"); + 28 : : // Only bit 31 may accompany the actual 29-bit identifier. + 29 [ + + ]: 750 : if ((rawId & 0x60000000U) != 0U) + 30 [ + - ]: 20 : throw std::runtime_error("CAN ID exceeds the 29-bit identifier range."); + 31 : 730 : return rawId; + 32 : : } + 33 : : + 34 : 1666 : double ParsePhysicalValue(const std::string &text, const char *field) { + 35 : : static const std::regex number( + 36 [ + + + - : 1666 : R"(^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$)"); + + - - - ] + 37 [ + - + + ]: 1666 : if (!std::regex_match(text, number)) + 38 [ + - + - : 336 : throw std::runtime_error(std::string("Invalid ") + field + ": " + text); + + - + - + + - ] + 39 : : // Floating-point from_chars is locale-independent and does not accept + 40 : : // a leading '+', which the DBC numeric grammar permits. + 41 : 1554 : const char *begin = text.data(); + 42 : 1554 : const char *end = begin + text.size(); + 43 [ + + ]: 1554 : if (*begin == '+') + 44 : 18 : ++begin; + 45 : 1554 : double value = 0.0; + 46 : : const std::from_chars_result parsed = + 47 : 1554 : std::from_chars(begin, end, value, std::chars_format::general); + 48 : : // Keep the existing rejection of conversion underflow into subnormal values. + 49 [ + + + - : 3084 : if (parsed.ec != std::errc() || parsed.ptr != end || !std::isfinite(value) || + + - + + + + + ] + 50 : 1530 : std::fpclassify(value) == FP_SUBNORMAL) + 51 [ + - + - : 120 : throw std::runtime_error(std::string("Invalid ") + field + ": " + text); + + - + - + + - ] + 52 : 1514 : return value; + 53 : : } + 54 : : + 55 : 496 : Multiplexing ParseMultiplexingMarker(const std::string &marker) { + 56 : 496 : Multiplexing result; + 57 [ + - + + ]: 496 : if (marker == "M") + 58 : 34 : result.role = MultiplexRole::Selector; + 59 [ + + ]: 462 : else if (!marker.empty()) { + 60 [ + + ]: 38 : if (marker[0] != 'm') + 61 [ + - ]: 1 : throw std::runtime_error("Unsupported multiplexing marker."); + 62 [ + - ]: 37 : const std::string value = marker.substr(1U); + 63 : : const std::from_chars_result parsed = + 64 [ + - ]: 37 : std::from_chars(value.data(), value.data() + value.size(), result.value); + 65 [ + + + + : 37 : if (value.empty() || parsed.ec != std::errc() || parsed.ptr != value.data() + value.size()) + + + + + ] + 66 [ + - ]: 7 : throw std::runtime_error("Invalid or unsupported multiplexing marker."); + 67 : 30 : result.role = MultiplexRole::Branch; + 68 : 37 : } + 69 : : + 70 : 488 : return result; + 71 : : } + 72 : : + 73 : 104 : RawSignalValue ParseValueKey(const std::string &number) { + 74 : 104 : RawSignalValue key; + 75 [ + - + + : 104 : if (!number.empty() && number[0] == '-') { + + + ] + 76 : 16 : std::int64_t value = 0; + 77 : : const std::from_chars_result parsed = + 78 [ + - ]: 16 : std::from_chars(number.data(), number.data() + number.size(), value); + 79 [ + + - + : 16 : if (parsed.ec != std::errc() || parsed.ptr != number.data() + number.size()) + + + ] + 80 [ + - + - ]: 2 : throw std::runtime_error("Invalid VAL_ integer: " + number); + 81 : 14 : key = NormalizeValueKey(RawSignalValue(value)); + 82 : : } else { + 83 : 88 : std::uint64_t value = 0; + 84 : : const std::from_chars_result parsed = + 85 [ + - ]: 88 : std::from_chars(number.data(), number.data() + number.size(), value); + 86 [ + - + + : 88 : if (number.empty() || parsed.ec != std::errc() || parsed.ptr != number.data() + number.size()) + + + + + ] + 87 [ + - + - ]: 6 : throw std::runtime_error("Invalid VAL_ integer: " + number); + 88 : 82 : key = value; + 89 : : } + 90 : 96 : return key; + 91 : : } + 92 : : + 93 : 96 : std::string UnescapeDescription(const std::string "ed) { + 94 : 96 : std::string description; + 95 [ + + ]: 724 : for (std::size_t i = 0; i < quoted.size(); ++i) { + 96 [ + + ]: 628 : if (quoted[i] == '\\') + 97 : 7 : ++i; + 98 [ + - ]: 628 : description += quoted[i]; + 99 : : } + 100 : 96 : return description; + 101 : 0 : } + 102 : : + 103 : 67 : FrameInfo *FindUniqueFrame(DbcDatabase &database, std::uint32_t canId, bool isExtended) { + 104 : 67 : FrameInfo *frame = nullptr; + 105 [ + + ]: 178 : for (FrameInfo &candidate : database.frames) { + 106 [ + + + + ]: 113 : if (candidate.canId == canId && candidate.isExtended == isExtended) { + 107 [ + + ]: 66 : if (frame) + 108 [ + - ]: 2 : throw std::runtime_error("Ambiguous VAL_ frame reference."); + 109 : 64 : frame = &candidate; + 110 : : } + 111 : : } + 112 [ + + ]: 65 : if (!frame) + 113 [ + - ]: 3 : throw std::runtime_error("Unresolved VAL_ frame reference."); + 114 : 62 : return frame; + 115 : : } + 116 : : + 117 : 62 : SignalInfo *FindUniqueSignal(FrameInfo &frame, const std::string &signalName) { + 118 : 62 : SignalInfo *signal = nullptr; + 119 [ + + ]: 149 : for (SignalInfo &candidate : frame.signals) { + 120 [ + + ]: 89 : if (candidate.name == signalName) { + 121 [ + + ]: 59 : if (signal) + 122 [ + - + - ]: 2 : throw std::runtime_error("Ambiguous VAL_ signal reference: " + signalName); + 123 : 57 : signal = &candidate; + 124 : : } + 125 : : } + 126 [ + + ]: 60 : if (!signal) + 127 [ + - + - ]: 5 : throw std::runtime_error("Unresolved VAL_ signal reference: " + signalName); + 128 : 55 : return signal; + 129 : : } + 130 : : + 131 : 884 : std::uint64_t NextSignalBit(std::uint64_t bit, bool isLittleEndian) { + 132 [ + + ]: 884 : if (isLittleEndian) + 133 : 724 : return bit + 1U; + 134 : : // From bit 0, Motorola continues at bit 7 of the next byte (0 -> 15). + 135 [ + + ]: 160 : return bit % 8U == 0U ? bit + 15U : bit - 1U; + 136 : : } + 137 : : + 138 : : FrameInfo *FindFrameById(DbcDatabase &, std::uint32_t, bool); + 139 : : SignalInfo *FindSignalByName(FrameInfo &, const std::string &); + 140 : : } // namespace + 141 : : + 142 : : namespace { + 143 : 317 : std::vector<std::string> SplitReceivers(const std::string &text) { + 144 : 317 : std::vector<std::string> receivers; + 145 : 317 : std::string token; + 146 [ + - ]: 317 : std::istringstream stream(text); + 147 : : + 148 [ + - + - : 956 : while (std::getline(stream, token, ',')) { + + + ] + 149 [ + - ]: 322 : token = dbc_detail::TrimText(token); + 150 [ - + ]: 322 : if (!token.empty()) + 151 [ + - ]: 322 : receivers.push_back(token); + 152 : : } + 153 : : + 154 : 317 : return receivers; + 155 : 317 : } + 156 : : + 157 : 803 : void NormalizeCanId(std::uint32_t rawCanId, std::uint32_t &normalizedCanId, bool &isExtended) { + 158 : : /* + 159 : : * DBC commonly stores extended identifiers with bit 31 set. + 160 : : * Example: + 161 : : * raw id = 0x80000000 | actual_29_bit_id + 162 : : */ + 163 [ + + + + ]: 803 : isExtended = (rawCanId & 0x80000000U) != 0U || rawCanId > 0x7FFU; + 164 : 803 : normalizedCanId = rawCanId & 0x1FFFFFFFU; + 165 : 803 : } + 166 : : } // namespace + 167 : : + 168 : 649 : FrameInfo DbcFrameHandler::ParseFrameLine(const std::string &line) { + 169 : : /* + 170 : : * Example: + 171 : : * BO_ 256 EngineData: 8 EEC1 + 172 : : */ + 173 : : + 174 [ + - ]: 649 : std::istringstream stream(line); + 175 : 649 : std::string keyword; + 176 : 649 : std::string idText; + 177 [ + - + - : 649 : if (!(stream >> keyword >> idText) || keyword != "BO_") + + - + + + + - - + + + + ] + 178 [ + - ]: 3 : throw std::runtime_error("Missing CAN ID in frame definition."); + 179 : : + 180 [ + + ]: 646 : const std::uint32_t rawCanId = ParseCanId(idText); + 181 : : + 182 : 628 : std::string nameText; + 183 [ + - + - : 628 : if (!std::getline(stream, nameText, ':') || stream.eof()) + + + + - + + + + + ] + 184 [ + - ]: 2 : throw std::runtime_error("Missing ':' in frame definition."); + 185 [ + - ]: 626 : std::istringstream nameStream(nameText); + 186 : 626 : FrameInfo frame; + 187 : 626 : std::string extra; + 188 [ + - + - : 626 : if (!(nameStream >> frame.name) || (nameStream >> extra)) + + + + - + + - + + + + + ] + 189 [ + - ]: 2 : throw std::runtime_error("Missing or invalid frame name."); + 190 : : + 191 : 624 : std::string lengthText; + 192 [ + - + - : 624 : if (!(stream >> lengthText)) + + + ] + 193 [ + - ]: 1 : throw std::runtime_error("Missing payload length in frame definition."); + 194 [ + + ]: 623 : frame.dlc = static_cast<std::uint8_t>(ParseDecimal( + 195 : 623 : lengthText, std::numeric_limits<std::uint8_t>::max(), "payload length")); + 196 [ + - + - : 617 : if (!(stream >> frame.transmitter)) + + + ] + 197 [ + - ]: 1 : throw std::runtime_error("Missing transmitter in frame definition."); + 198 [ + - + - : 616 : if (stream >> extra) + + + ] + 199 [ + - + - ]: 1 : throw std::runtime_error("Unexpected trailing field in frame definition: " + extra); + 200 : : + 201 : 615 : NormalizeCanId(rawCanId, frame.canId, frame.isExtended); + 202 : : + 203 : 615 : return frame; + 204 : 772 : } + 205 : : + 206 : 521 : SignalInfo DbcSignalHandler::ParseSignalLine(const std::string &line) { + 207 : : // Match the complete statement before converting any numeric fields. + 208 : : enum Field { + 209 : : NameAndMarker = 1, StartBit, BitLength, ByteOrder, Signedness, + 210 : : Factor, Offset, Minimum, Maximum, Unit, Receivers + 211 : : }; + 212 : : static const std::regex syntax( + 213 : : // Name and optional multiplexing marker. + 214 : : R"dbc(^SG_[ \t]+([^:]+):[ \t]*)dbc" + 215 : : // Bit position, length, byte order and signedness. + 216 : : R"dbc(([^| \t]+)[ \t]*\|[ \t]*([^@ \t]+)[ \t]*@[ \t]*([01])([+-])[ \t]*)dbc" + 217 : : // Scaling factor and offset. + 218 : : R"dbc(\([ \t]*([^, \t]+)[ \t]*,[ \t]*([^ )\t]+)[ \t]*\)[ \t]*)dbc" + 219 : : // Physical range. + 220 : : R"dbc(\[[ \t]*([^| \t]+)[ \t]*\|[ \t]*([^\] \t]+)[ \t]*\][ \t]*)dbc" + 221 : : // Unit and receivers. + 222 [ + + + - : 521 : R"dbc("([^"\r\n]*)"[ \t]+([^ \t,]+(?:[ \t]*,[ \t]*[^ \t,]+)*)[ \t]*$)dbc"); + + - - - ] + 223 : 521 : std::smatch fields; + 224 [ + - + + ]: 521 : if (!std::regex_match(line, fields, syntax)) + 225 [ + - ]: 23 : throw std::runtime_error("Malformed or unsupported SG_ signal definition."); + 226 : : + 227 : 498 : SignalInfo signal; + 228 [ + - + - : 498 : std::istringstream nameFields(fields[NameAndMarker].str()); + + - ] + 229 : 498 : std::string marker; + 230 : 498 : std::string extra; + 231 [ + - + - ]: 498 : nameFields >> signal.name >> marker; + 232 [ + + + - : 498 : if (signal.name.empty() || (nameFields >> extra)) + + - + + + + + ] + 233 [ + - ]: 2 : throw std::runtime_error("Invalid signal name or multiplexing marker."); + 234 [ + + ]: 496 : signal.multiplexing = ParseMultiplexingMarker(marker); + 235 : : + 236 [ + - + - : 495 : signal.startBit = ParseDecimal(fields[StartBit].str(), + + + ] + 237 : : std::numeric_limits<std::uint32_t>::max(), "signal start bit"); + 238 [ + - + - : 489 : signal.length = ParseDecimal(fields[BitLength].str(), 64U, "signal length"); + + + ] + 239 [ + + ]: 473 : if (signal.length == 0U) + 240 [ + - ]: 1 : throw std::runtime_error("Signal length must be within 1..64 bits."); + 241 [ + - + - : 472 : signal.isLittleEndian = fields[ByteOrder].str() == "1"; + + - ] + 242 [ + - + - : 472 : signal.isSigned = fields[Signedness].str() == "-"; + + - ] + 243 : : + 244 [ + - + - : 504 : signal.factor = ParsePhysicalValue(fields[Factor].str(), "signal factor"); + + + ] + 245 [ + - + - : 484 : signal.offset = ParsePhysicalValue(fields[Offset].str(), "signal offset"); + + + ] + 246 [ + - + - : 434 : signal.minimum = ParsePhysicalValue(fields[Minimum].str(), "signal minimum"); + + + ] + 247 [ + - + - : 396 : signal.maximum = ParsePhysicalValue(fields[Maximum].str(), "signal maximum"); + + + ] + 248 [ + + ]: 320 : if (signal.minimum > signal.maximum) + 249 [ + - ]: 3 : throw std::runtime_error("Signal minimum exceeds maximum."); + 250 [ + - + - ]: 317 : signal.unit = fields[Unit].str(); + 251 [ + - + - : 317 : signal.receivers = SplitReceivers(fields[Receivers].str()); + + - ] + 252 : 317 : return signal; + 253 : 1245 : } + 254 : : + 255 : : + 256 : : namespace { + 257 : 698 : FrameInfo *FindFrameById(DbcDatabase &database, + 258 : : std::uint32_t canId, + 259 : : bool isExtended) { + 260 [ + + ]: 757 : for (FrameInfo &frame : database.frames) { + 261 [ + + + + ]: 144 : if (frame.canId == canId && frame.isExtended == isExtended) + 262 : 85 : return &frame; + 263 : : } + 264 : : + 265 : 613 : return nullptr; + 266 : : } + 267 : : + 268 : 364 : SignalInfo *FindSignalByName(FrameInfo &frame, const std::string &signalName) { + 269 [ + + ]: 441 : for (SignalInfo &signal : frame.signals) { + 270 [ + + ]: 126 : if (signal.name == signalName) + 271 : 49 : return &signal; + 272 : : } + 273 : : + 274 : 315 : return nullptr; + 275 : : } + 276 : : }// namespace + 277 : : + 278 : 649 : void DbcFrameHandler::Handle(const std::string &line, DbcParseContext &context) const { + 279 [ + + ]: 649 : FrameInfo frame = ParseFrameLine(line); + 280 [ + + + + ]: 615 : if (context.enableJ1939 && frame.isExtended) { + 281 : 27 : frame.hasPgn = true; + 282 : 27 : frame.pgn = ExtractJ1939Pgn(frame.canId); + 283 : : } + 284 [ + + ]: 615 : if (FindFrameById(context.database, frame.canId, frame.isExtended) != nullptr) + 285 [ + + + - : 16 : throw std::runtime_error("Duplicate " + std::string(frame.isExtended ? "extended" : "standard") + + + - ] + 286 [ + - + - : 24 : " frame CAN ID: " + std::to_string(frame.canId)); + + - ] + 287 [ + - ]: 607 : context.database.frames.push_back(std::move(frame)); + 288 : 607 : context.currentFrame = &context.database.frames.back(); + 289 [ + - ]: 607 : context.signalLines.emplace_back(); + 290 : 615 : } + 291 : : + 292 : 526 : void DbcSignalHandler::Handle(const std::string &line, DbcParseContext &context) const { + 293 [ + + ]: 526 : if (context.currentFrame == nullptr) + 294 [ + - ]: 5 : throw std::runtime_error("Signal found before any frame definition."); + 295 [ + + ]: 521 : SignalInfo signal = ParseSignalLine(line); + 296 [ + + ]: 317 : if (FindSignalByName(*context.currentFrame, signal.name) != nullptr) + 297 : 6 : throw std::runtime_error("Duplicate signal name '" + signal.name + + 298 [ + - + - : 12 : "' in frame '" + context.currentFrame->name + "'."); + + - + - + + - ] + 299 [ + + ]: 311 : if (!IsValidSignalLayout(signal.startBit, signal.length, signal.isLittleEndian, + 300 : 311 : context.currentFrame->dlc)) + 301 [ + - ]: 7 : throw std::runtime_error("Signal exceeds the frame payload length."); + 302 [ + - ]: 304 : context.currentFrame->signals.push_back(std::move(signal)); + 303 [ + - ]: 304 : context.signalLines.back().push_back(context.lineNumber); + 304 : 317 : } + 305 : : + 306 : 149 : void DbcCommentHandler::Handle(const std::string &line, DbcParseContext &context) const { + 307 [ + - ]: 149 : std::istringstream stream(line); + 308 : 149 : std::string keyword; + 309 : 149 : std::string target; + 310 [ + - + - ]: 149 : stream >> keyword >> target; + 311 [ + - + + : 149 : if (keyword != "CM_" || (target != "BO_" && target != "SG_")) + + - + + + + - + + + + + ] + 312 : 9 : return; + 313 : : + 314 : 140 : PendingComment pending; + 315 [ + - ]: 140 : pending.isSignal = target == "SG_"; + 316 : 140 : pending.lineNumber = context.lineNumber; + 317 : 140 : std::string idText; + 318 [ + - + - : 140 : if (!(stream >> idText)) + + + ] + 319 [ + - ]: 2 : throw std::runtime_error("Missing CAN ID in CM_ statement."); + 320 [ + + ]: 138 : NormalizeCanId(ParseCanId(idText), pending.canId, pending.isExtended); + 321 [ + + + - : 157 : if (pending.isSignal && (!(stream >> pending.signalName) || + + - + - + + + + + ] + 322 : 55 : pending.signalName.find_first_of("\";") != std::string::npos)) + 323 [ + - ]: 2 : throw std::runtime_error("Missing or invalid signal name in CM_ statement."); + 324 : : + 325 [ + - ]: 100 : stream >> std::ws; + 326 [ + - + + ]: 100 : if (stream.get() != '"') + 327 [ + - ]: 4 : throw std::runtime_error("Missing opening quote in CM_ statement."); + 328 : 96 : bool closed = false; + 329 : : char character; + 330 [ + - + - : 1096 : while (stream.get(character)) { + + + ] + 331 [ + + ]: 1094 : if (character == '"') { + 332 : 90 : closed = true; + 333 : 90 : break; + 334 : : } + 335 [ + + ]: 1004 : if (character == '\\') { + 336 [ + - + - : 7 : if (!stream.get(character) || (character != '"' && character != '\\')) + + + + + + + + + + ] + 337 [ + - ]: 4 : throw std::runtime_error("Invalid escape in CM_ statement."); + 338 : : } + 339 [ + - ]: 1000 : pending.comment += character; + 340 : : } + 341 [ + + ]: 92 : if (!closed) + 342 [ + - ]: 2 : throw std::runtime_error("Unterminated CM_ comment."); + 343 [ + - ]: 90 : stream >> std::ws; + 344 [ + - + + ]: 90 : if (stream.get() != ';') + 345 [ + - ]: 4 : throw std::runtime_error("Missing semicolon in CM_ statement."); + 346 [ + - ]: 86 : stream >> std::ws; + 347 [ + - + + ]: 86 : if (!stream.eof()) + 348 [ + - ]: 2 : throw std::runtime_error("Unexpected trailing text in CM_ statement."); + 349 [ + - ]: 84 : context.pendingComments.push_back(std::move(pending)); + 350 [ + + + + : 391 : } + + + ] + 351 : : + 352 : 597 : void DbcParseContext::ResolveComments(const std::string &filePath) { + 353 [ + + ]: 670 : for (const PendingComment &pending: pendingComments) { + 354 : 83 : FrameInfo *frame = FindFrameById(database, pending.canId, pending.isExtended); + 355 [ + + ]: 83 : if (!frame) + 356 : : throw DbcDiagnosticError(DbcDiagnosticCode::InvalidStatement, filePath, + 357 [ + - + - ]: 18 : pending.lineNumber, "Unresolved CM_ frame reference."); + 358 [ + + ]: 77 : if (pending.isSignal) { + 359 : 47 : SignalInfo *signal = FindSignalByName(*frame, pending.signalName); + 360 [ + + ]: 47 : if (!signal) + 361 : : throw DbcDiagnosticError(DbcDiagnosticCode::InvalidStatement, filePath, + 362 [ + - + - ]: 4 : pending.lineNumber, "Unresolved CM_ signal reference: " + pending.signalName); + 363 [ + - ]: 43 : signal->comment = pending.comment; + 364 : : } else { + 365 [ + - ]: 30 : frame->comment = pending.comment; + 366 : : } + 367 : : } + 368 : 587 : } + 369 : : + 370 : 949 : DbcStatementDispatcher::DbcStatementDispatcher() { + 371 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("VERSION"); + 372 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("NS_"); + 373 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("NS_:"); + 374 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("BS_"); + 375 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("BS_:"); + 376 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("BU_"); + 377 [ + - + - ]: 1898 : RegisterType<DbcHeaderHandler>("BU_:"); + 378 [ + - + - ]: 1898 : RegisterType<DbcUnsupportedMultiplexingHandler>("SG_MUL_VAL_"); + 379 [ + - + - ]: 1898 : RegisterType<DbcFrameHandler>("BO_"); + 380 [ + - + - ]: 1898 : RegisterType<DbcSignalHandler>("SG_"); + 381 [ + - + - ]: 1898 : RegisterType<DbcCommentHandler>("CM_"); + 382 [ + - + - ]: 1898 : RegisterType<DbcValueDescriptionHandler>("VAL_"); + 383 [ + - + - ]: 1898 : RegisterType<DbcAttributeHandler>("BA_DEF_"); + 384 [ + - + - ]: 1898 : RegisterType<DbcAttributeHandler>("BA_DEF_DEF_"); + 385 [ + - + - ]: 949 : RegisterType<DbcAttributeHandler>("BA_"); + 386 : 949 : } + 387 : : + 388 : 62 : void DbcHeaderHandler::Handle(const std::string &, DbcParseContext &) const {} + 389 : : + 390 : 2132 : bool DbcStatementDispatcher::Dispatch(const std::string &line, + 391 : : DbcParseContext &context) const { + 392 [ + - ]: 2132 : std::istringstream stream(line); + 393 : 2132 : std::string keyword; + 394 [ + - ]: 2132 : stream >> keyword; + 395 [ + - ]: 2132 : const HandlerMap::const_iterator handler = m_handlers.find(keyword); + 396 [ + + ]: 2132 : if (handler == m_handlers.end()) + 397 : 40 : return false; + 398 [ + + ]: 2092 : handler->second->Handle(line, context); + 399 : 1743 : return true; + 400 : 2481 : } + 401 : : + 402 : 94 : void DbcValueDescriptionHandler::Handle(const std::string &line, DbcParseContext &context) const { + 403 [ + + + - : 94 : static const std::regex header(R"(^VAL_[ \t]+([^ \t]+)[ \t]+([^ \t;]+)[ \t]+(.*)$)"); + + - - - ] + 404 [ + + + - : 94 : static const std::regex pair(R"dbc(^([^ \t]+)[ \t]+"((?:[^"\\]|\\["\\])*)")dbc"); + + - - - ] + 405 : 94 : std::smatch fields; + 406 [ + - + + ]: 94 : if (!std::regex_match(line, fields, header)) + 407 [ + - ]: 4 : throw std::runtime_error("Malformed or unsupported VAL_ statement."); + 408 [ + - + - : 93 : const std::uint32_t rawId = ParseDecimal(fields[1].str(), std::numeric_limits<std::uint32_t>::max(), "VAL_ CAN ID"); + + + ] + 409 [ + + ]: 87 : if ((rawId & 0x60000000U) != 0U) + 410 [ + - ]: 1 : throw std::runtime_error("VAL_ CAN ID exceeds the 29-bit identifier range."); + 411 : 86 : PendingValueDescriptions pending; + 412 : 86 : NormalizeCanId(rawId, pending.canId, pending.isExtended); + 413 [ + - + - ]: 86 : pending.signalName = fields[2].str(); + 414 : 86 : pending.lineNumber = context.lineNumber; + 415 [ + - + - ]: 86 : std::string rest = fields[3].str(); + 416 [ + - + + ]: 179 : while (rest != ";") { + 417 [ + - + + ]: 109 : if (!std::regex_search(rest, fields, pair)) + 418 [ + - ]: 5 : throw std::runtime_error("Malformed VAL_ value/description pair or missing semicolon."); + 419 [ + - + - ]: 104 : const std::string number = fields[1].str(); + 420 [ + + ]: 104 : const RawSignalValue key = ParseValueKey(number); + 421 [ + - + - : 96 : const std::string description = UnescapeDescription(fields[2].str()); + + - ] + 422 [ + - + + ]: 96 : if (!pending.descriptions.emplace(key, description).second) + 423 [ + - + - ]: 2 : throw std::runtime_error("Duplicate VAL_ value key: " + number); + 424 [ + - ]: 94 : const std::size_t consumed = static_cast<std::size_t>(fields.length()); + 425 [ + - ]: 94 : rest.erase(0, consumed); + 426 [ + + + - : 94 : if (!rest.empty() && rest[0] != ';' && rest[0] != ' ' && rest[0] != '\t') + + + + - + + + + - + + + + + ] + 427 [ + - ]: 1 : throw std::runtime_error("Missing whitespace between VAL_ pairs."); + 428 [ + - ]: 93 : rest = dbc_detail::TrimText(rest); + 429 : 107 : } + 430 [ + + ]: 70 : if (pending.descriptions.empty()) + 431 [ + - ]: 1 : throw std::runtime_error("VAL_ requires at least one value/description pair."); + 432 [ + - ]: 69 : context.pendingValues.push_back(std::move(pending)); + 433 : 128 : } + 434 : : + 435 : 592 : void DbcParseContext::ResolveValueDescriptions(const std::string &filePath) { + 436 [ + + ]: 644 : for (const PendingValueDescriptions &pending: pendingValues) { + 437 : : try { + 438 [ + + ]: 67 : FrameInfo *frame = FindUniqueFrame(database, pending.canId, pending.isExtended); + 439 [ + + ]: 62 : SignalInfo *signal = FindUniqueSignal(*frame, pending.signalName); + 440 [ + + ]: 127 : for (const ValueDescriptions::value_type &entry: pending.descriptions) { + 441 [ + - + + ]: 75 : if (!signal->valueDescriptions.insert(entry).second) + 442 [ + - + - ]: 3 : throw std::runtime_error("Duplicate VAL_ value key for signal: " + pending.signalName); + 443 : : } + 444 [ - + ]: 15 : } catch (const std::exception &error) { + 445 : : throw DbcDiagnosticError(DbcDiagnosticCode::InvalidValueDescription, + 446 [ + - + - ]: 45 : filePath, pending.lineNumber, error.what()); + 447 : 15 : } + 448 : : } + 449 : 577 : } + 450 : : + 451 : 4 : void DbcUnsupportedMultiplexingHandler::Handle(const std::string &, DbcParseContext &) const { + 452 [ + - ]: 4 : throw std::runtime_error("Extended and nested multiplexing are unsupported."); + 453 : : } + 454 : : + 455 : : namespace { + 456 : 114 : std::vector<std::uint64_t> SignalBits(const SignalInfo &signal) { + 457 : 114 : std::vector<std::uint64_t> bits; + 458 : 114 : std::uint64_t bit = signal.startBit; + 459 [ + + ]: 998 : for (std::uint32_t index = 0U; index < signal.length; ++index) { + 460 [ + - ]: 884 : bits.push_back(bit); + 461 : 884 : bit = NextSignalBit(bit, signal.isLittleEndian); + 462 : : } + 463 : 114 : return bits; + 464 : 0 : } + 465 : : + 466 : 58 : bool AreMutuallyExclusive(const SignalInfo &first, const SignalInfo &second) { + 467 : 79 : return first.multiplexing.role == MultiplexRole::Branch && + 468 [ + + + + ]: 62 : second.multiplexing.role == MultiplexRole::Branch && + 469 [ + + ]: 62 : first.multiplexing.value != second.multiplexing.value; + 470 : : } + 471 : : + 472 : 193 : std::string ValidateBranch(const SignalInfo &signal, const SignalInfo *selector) { + 473 [ + + ]: 193 : if (signal.multiplexing.role != MultiplexRole::Branch) + 474 : 164 : return {}; + 475 [ + + ]: 29 : if (selector == nullptr) + 476 [ + - ]: 8 : return "Multiplexed branch has no selector."; + 477 [ + + + + ]: 25 : if (selector->length < 64U && signal.multiplexing.value >= (std::uint64_t(1U) << selector->length)) + 478 [ + - ]: 10 : return "Branch value exceeds selector raw range."; + 479 : 20 : return {}; + 480 : : } + 481 : : + 482 : 280 : const SignalInfo *FindSelector(const FrameInfo &frame, + 483 : : const std::vector<std::size_t> &lines, + 484 : : const std::string &filePath) { + 485 : 280 : const SignalInfo *selector = nullptr; + 486 [ + + ]: 479 : for (std::size_t index = 0U; index < frame.signals.size(); ++index) { + 487 : 207 : const SignalInfo &signal = frame.signals[index]; + 488 [ + + ]: 207 : if (signal.multiplexing.role != MultiplexRole::Selector) + 489 : 173 : continue; + 490 [ + + + + ]: 34 : if (selector != nullptr || signal.isSigned) + 491 : : throw DbcDiagnosticError(DbcDiagnosticCode::InvalidMultiplexing, + 492 : 8 : filePath, lines[index], + 493 [ + - + - ]: 32 : "Multiplexing requires one unsigned selector per frame."); + 494 : 26 : selector = &signal; + 495 : : } + 496 : 272 : return selector; + 497 : : } + 498 : : + 499 : 57 : bool SignalsOverlap(const SignalInfo &first, const SignalInfo &second) { + 500 [ + - ]: 57 : const std::vector<std::uint64_t> firstBits = SignalBits(first); + 501 [ + - ]: 57 : const std::vector<std::uint64_t> secondBits = SignalBits(second); + 502 [ + + ]: 489 : for (const std::uint64_t firstBit : firstBits) { + 503 [ + + ]: 3380 : for (const std::uint64_t secondBit : secondBits) { + 504 [ + + ]: 2948 : if (firstBit == secondBit) + 505 : 10 : return true; + 506 : : } + 507 : : } + 508 : 47 : return false; + 509 : 57 : } + 510 : : } + 511 : : + 512 : 576 : void DbcParseContext::ValidateMultiplexing(const std::string &filePath) const { + 513 [ + + ]: 829 : for (std::size_t frameIndex = 0U; frameIndex < database.frames.size(); ++frameIndex) { + 514 : 280 : const FrameInfo &frame = database.frames[frameIndex]; + 515 : 280 : const SignalInfo *selector = FindSelector(frame, signalLines[frameIndex], filePath); + 516 [ + + ]: 446 : for (std::size_t index = 0U; index < frame.signals.size(); ++index) { + 517 : 193 : const SignalInfo &signal = frame.signals[index]; + 518 [ + - ]: 193 : std::string error = ValidateBranch(signal, selector); + 519 [ + + + + : 251 : for (std::size_t previous = 0U; previous < index && error.empty(); ++previous) { + + + ] + 520 : 58 : const SignalInfo &other = frame.signals[previous]; + 521 [ + + + - : 58 : if (!AreMutuallyExclusive(signal, other) && SignalsOverlap(signal, other)) + + + + + ] + 522 [ + - ]: 10 : error = "Signals overlap without mutually exclusive multiplexing conditions."; + 523 : : } + 524 [ + + ]: 193 : if (!error.empty()) + 525 : : throw DbcDiagnosticError(DbcDiagnosticCode::InvalidMultiplexing, + 526 [ + - ]: 19 : filePath, signalLines[frameIndex][index], error); + 527 : 193 : } + 528 : : } + 529 : 549 : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #ifndef DBC_STATEMENT_HANDLER_H + 3 : : #define DBC_STATEMENT_HANDLER_H + 4 : : + 5 : : #include "dbc_database.h" + 6 : : #include "dbc_diagnostic.h" + 7 : : #include "typefactory.h" + 8 : : #include <stdexcept> + 9 : : #include <string> + 10 : : #include <unordered_map> + 11 : : + 12 : : /** @brief Deferred raw value descriptions and their target. */ + 13 : : struct PendingValueDescriptions { + 14 : : std::uint32_t canId; /**< Normalized target frame identifier. */ + 15 : : bool isExtended; /**< Target frame type. */ + 16 : : std::string signalName; /**< Target signal name. */ + 17 : : ValueDescriptions descriptions; /**< Raw integer descriptions to merge. */ + 18 : : std::size_t lineNumber; /**< One-based physical statement line. */ + 19 : : }; + 20 : : + 21 : : /** @brief Deferred frame or signal comment and its source location. */ + 22 : : struct PendingComment { + 23 : : std::uint32_t canId; /**< Normalized target frame identifier. */ + 24 : : bool isExtended; /**< Target frame type. */ + 25 : : bool isSignal; /**< Whether the target is a signal rather than a frame. */ + 26 : : std::string signalName; /**< Target signal name. */ + 27 : : std::string comment; /**< Unescaped comment text. */ + 28 : : std::size_t lineNumber; /**< One-based physical statement line. */ + 29 : : }; + 30 : : + 31 : : /** Carries deferred validation locations without parsing exception text. */ + 32 : : class DbcDiagnosticError : public std::runtime_error { + 33 : : public: + 34 : : /** @brief Create an exception with a structured source diagnostic. */ + 35 : 438 : DbcDiagnosticError(DbcDiagnosticCode code, const std::string &filePath, + 36 : : std::size_t lineNumber, const std::string &message) + 37 [ + - + - : 876 : : std::runtime_error(filePath + ":" + std::to_string(lineNumber) + ": " + message), + + - + - ] + 38 [ + - + - : 1314 : diagnostic{DbcDiagnosticSeverity::Error, code, filePath, lineNumber, message} {} + + - + - - + - ] + 39 : : + 40 : : DbcDiagnostic diagnostic; /**< Structured error accompanying the exception message. */ + 41 : : }; + 42 : : + 43 : : /** @brief Attribute statement retained for ordered resolution. */ + 44 : : struct PendingAttribute { + 45 : : std::string statement; /**< Complete attribute statement. */ + 46 : : std::size_t lineNumber; /**< One-based physical statement line. */ + 47 : : }; + 48 : : + 49 : : /** Mutable state belonging to one file parse. Handlers do not retain it. */ + 50 : : struct DbcParseContext { + 51 : : DbcDatabase &database; /**< Parsed metadata under construction. */ + 52 : : FrameInfo *currentFrame = nullptr; /**< Current frame for following signal definitions. */ + 53 : : bool enableJ1939 = false; /**< Explicit interpretation option for extended frames. */ + 54 : : std::size_t lineNumber = 0U; /**< Physical line of the current statement. */ + 55 : : std::vector<PendingValueDescriptions> pendingValues = {}; /**< Unresolved raw value descriptions. */ + 56 : : + 57 : : std::vector<std::vector<std::size_t>> signalLines = {}; /**< Signal definition lines grouped by frame. */ + 58 : : /** @brief Validate selectors, branch ranges, and signal overlap. */ + 59 : : void ValidateMultiplexing(const std::string &filePath) const; + 60 : : + 61 : : std::vector<PendingComment> pendingComments = {}; /**< Unresolved comments in source order. */ + 62 : : /** @brief Resolve deferred comments after all definitions are known. */ + 63 : : void ResolveComments(const std::string &filePath); + 64 : : + 65 : : std::vector<PendingAttribute> pendingAttributes = {}; /**< Unresolved attributes in source order. */ + 66 : : /** @brief Resolve definitions, defaults, then assignments; append format warnings. */ + 67 : : void ResolveAttributes(const std::string &filePath, std::vector<DbcDiagnostic> &diagnostics); + 68 : : + 69 : : /** @brief Resolve deferred raw descriptions against unique targets. */ + 70 : : void ResolveValueDescriptions(const std::string &filePath); + 71 : : }; + 72 : : + 73 : : /** @brief Interface for processing a registered DBC statement. */ + 74 : : class DbcStatementHandler { + 75 : : public: + 76 : 14250 : virtual ~DbcStatementHandler() = default; + 77 : : /** @brief Process a trimmed statement using state belonging to this parse. */ + 78 : : virtual void Handle(const std::string &line, DbcParseContext &context) const = 0; + 79 : : }; + 80 : : + 81 : : /** @brief Parse and append frame definitions. */ + 82 : : class DbcFrameHandler : public DbcStatementHandler { + 83 : : public: + 84 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 85 : : + 86 : : private: + 87 : : static FrameInfo ParseFrameLine(const std::string &line); + 88 : : }; + 89 : : + 90 : : /** @brief Parse and append signals to the current frame. */ + 91 : : class DbcSignalHandler : public DbcStatementHandler { + 92 : : public: + 93 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 94 : : + 95 : : private: + 96 : : static SignalInfo ParseSignalLine(const std::string &line); + 97 : : }; + 98 : : + 99 : : /** @brief Defer frame and signal comments for target resolution. */ + 100 : : class DbcCommentHandler : public DbcStatementHandler { + 101 : : public: + 102 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 103 : : }; + 104 : : + 105 : : /** @brief Defer typed attribute statements for resolution. */ + 106 : : class DbcAttributeHandler : public DbcStatementHandler { + 107 : : public: + 108 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 109 : : }; + 110 : : + 111 : : /** @brief Defer raw value descriptions for target resolution. */ + 112 : : class DbcValueDescriptionHandler : public DbcStatementHandler { + 113 : : public: + 114 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 115 : : }; + 116 : : + 117 : : /** @brief Reject unsupported extended multiplexing statements. */ + 118 : : class DbcUnsupportedMultiplexingHandler : public DbcStatementHandler { + 119 : : public: + 120 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 121 : : }; + 122 : : + 123 : : /** Common header metadata does not change the supported decode definitions. */ + 124 : : class DbcHeaderHandler : public DbcStatementHandler { + 125 : : public: + 126 : : void Handle(const std::string &line, DbcParseContext &context) const override; + 127 : : }; + 128 : : + 129 : : /** Exact-key dispatch to handlers created once per registration via TypeFactory. */ + 130 : : class DbcStatementDispatcher { + 131 : : public: + 132 : : /** @brief Register supported statement handlers through TypeFactory. */ + 133 : : DbcStatementDispatcher(); + 134 : : + 135 : : /** @brief Register or replace a handler and create its reusable instance. */ + 136 : : template<class Handler> + 137 : 14236 : void RegisterType(const std::string &keyword) { + 138 : 14236 : m_factory.registerType<Handler>(keyword); + 139 [ + - + - ]: 14236 : m_handlers.insert_or_assign(keyword, m_factory.create(keyword)); + 140 : 14236 : } + 141 : : + 142 : : /** Returns false for an unregistered keyword; input must be trimmed. */ + 143 : : bool Dispatch(const std::string &line, DbcParseContext &context) const; + 144 : : + 145 : : private: + 146 : : using HandlerMap = std::unordered_map<std::string, std::shared_ptr<DbcStatementHandler>>; + 147 : : TypeFactory<std::string, DbcStatementHandler> m_factory; + 148 : : HandlerMap m_handlers; + 149 : : }; + 150 : : + 151 : : #endif /* DBC_STATEMENT_HANDLER_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcTreeBuilder::Build(DbcDatabase const&) const | + +22 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DbcTreeBuilder::Build(DbcDatabase const&) const | + +22 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : /** + 2 : : * @file dbc_tree_builder.cpp + 3 : : * @brief Construction of frame and signal metadata trees. + 4 : : * + 5 : : * Created: 2026-03-13 + 6 : : * Author: Deeaitch (Dim. Himro) + 7 : : * + 8 : : * Licensed under the MIT License. + 9 : : * See LICENSE file in the project root for full license text. + 10 : : */ + 11 : : + 12 : : #include "dbc_tree_builder.h" + 13 : : + 14 : 22 : std::unique_ptr<TreeNode> DbcTreeBuilder::Build(const DbcDatabase &database) const { + 15 : 22 : std::unique_ptr<TreeNode> root = std::make_unique<TreeNode>(); + 16 : : + 17 [ + + ]: 53 : for (const FrameInfo &frame : database.frames) { + 18 [ + - ]: 31 : std::unique_ptr<TreeNode> frameNode = std::make_unique<TreeNode>(frame); + 19 : : + 20 [ + + ]: 75 : for (const SignalInfo &signal : frame.signals) { + 21 [ + - ]: 44 : std::unique_ptr<TreeNode> signalNode = std::make_unique<TreeNode>(signal); + 22 [ + - ]: 44 : frameNode->AddChild(std::move(signalNode)); + 23 : 44 : } + 24 : : + 25 [ + - ]: 31 : root->AddChild(std::move(frameNode)); + 26 : 31 : } + 27 : : + 28 : 22 : return root; + 29 : 0 : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DecodeDatabase::FindSignal(SignalKey const&) const | + +53 | + + + +
| (anonymous namespace)::AreMutuallyExclusive(DecodeSignal const&, DecodeSignal const&) | + +71 | + + + +
| DecodeDatabase::GetFrames() const | + +76 | + + + +
| DecodeDatabase::FindFrameByPgn(unsigned int) const | + +116 | + + + +
| (anonymous namespace)::GetSignalBits(DecodeSignal const&) | + +2364 | + + + +
| DecodeDatabase::DecodeDatabase(std::vector<DecodeFrame, std::allocator<DecodeFrame> > const&) | + +2394 | + + + +
| DecodeDatabase::Storage::Storage(std::vector<DecodeFrame, std::allocator<DecodeFrame> > const&) | + +2394 | + + + +
| (anonymous namespace)::ValidateFrame(DecodeFrame const&) | + +2447 | + + + +
| (anonymous namespace)::ValidateSignal(DecodeSignal const&, unsigned char) | + +2476 | + + + +
| DecodeDatabase::FindFrame(FrameKey const&) const | + +6555 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| (anonymous namespace)::AreMutuallyExclusive(DecodeSignal const&, DecodeSignal const&) | + +71 | + + + +
| (anonymous namespace)::GetSignalBits(DecodeSignal const&) | + +2364 | + + + +
| (anonymous namespace)::ValidateFrame(DecodeFrame const&) | + +2447 | + + + +
| (anonymous namespace)::ValidateSignal(DecodeSignal const&, unsigned char) | + +2476 | + + + +
| DecodeDatabase::DecodeDatabase(std::vector<DecodeFrame, std::allocator<DecodeFrame> > const&) | + +2394 | + + + +
| DecodeDatabase::FindFrame(FrameKey const&) const | + +6555 | + + + +
| DecodeDatabase::FindFrameByPgn(unsigned int) const | + +116 | + + + +
| DecodeDatabase::FindSignal(SignalKey const&) const | + +53 | + + + +
| DecodeDatabase::GetFrames() const | + +76 | + + + +
| DecodeDatabase::Storage::Storage(std::vector<DecodeFrame, std::allocator<DecodeFrame> > const&) | + +2394 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : // Copyright (c) 2026 Dim Himro + 3 : : + 4 : : #include "decode_database.h" + 5 : : #include "j1939.h" + 6 : : #include "signal_layout.h" + 7 : : #include <bitset> + 8 : : #include <cmath> + 9 : : #include <limits> + 10 : : #include <stdexcept> + 11 : : #include <unordered_set> + 12 : : + 13 : : namespace { + 14 : : constexpr std::size_t MaximumPayloadBits = std::numeric_limits<std::uint8_t>::max() * 8U; + 15 : : using SignalBits = std::bitset<MaximumPayloadBits>; + 16 : : + 17 : 2476 : void ValidateSignal(const DecodeSignal &signal, std::uint8_t dlc) { + 18 [ + + + + ]: 2476 : if (signal.byteOrder != ByteOrder::Intel && signal.byteOrder != ByteOrder::Motorola) + 19 [ + - + - ]: 3 : throw std::invalid_argument("Invalid signal byte order: " + signal.name); + 20 [ + + + + ]: 2473 : if (signal.valueType != ValueType::Unsigned && signal.valueType != ValueType::Signed) + 21 [ + - + - ]: 3 : throw std::invalid_argument("Invalid signal value type: " + signal.name); + 22 [ + + ]: 2470 : if (signal.multiplexing.role != MultiplexRole::Unconditional && + 23 [ + + ]: 75 : signal.multiplexing.role != MultiplexRole::Selector && + 24 [ + + ]: 38 : signal.multiplexing.role != MultiplexRole::Branch) + 25 [ + - + - ]: 4 : throw std::invalid_argument("Invalid multiplexing role: " + signal.name); + 26 [ + + ]: 2466 : if (!IsValidSignalLayout(signal.startBit, signal.length, + 27 : 2466 : signal.byteOrder == ByteOrder::Intel, dlc)) + 28 [ + - + - ]: 36 : throw std::invalid_argument("Invalid signal length or payload position: " + signal.name); + 29 [ + + ]: 4847 : if (!std::isfinite(signal.factor) || !std::isfinite(signal.offset) || + 30 [ + + + + : 7240 : !std::isfinite(signal.minimum) || !std::isfinite(signal.maximum) || + + + + + ] + 31 [ + + ]: 2393 : signal.minimum > signal.maximum) + 32 [ + - + - ]: 39 : throw std::invalid_argument("Invalid signal numeric parameters: " + signal.name); + 33 : 2391 : } + 34 : : + 35 : 2364 : SignalBits GetSignalBits(const DecodeSignal &signal) { + 36 : 2364 : SignalBits bits; + 37 : 2364 : const bool littleEndian = signal.byteOrder == ByteOrder::Intel; + 38 : 2364 : const std::uint64_t start = SignalStartCoordinate(signal.startBit, littleEndian); + 39 [ + + ]: 75593 : for (std::uint32_t index = 0U; index < signal.length; ++index) { + 40 : 73229 : const std::uint64_t coordinate = start + index; + 41 [ + + ]: 73229 : const std::uint64_t bit = littleEndian ? coordinate + 42 : 36098 : : coordinate / 8U * 8U + 7U - coordinate % 8U; + 43 : 73229 : bits.set(static_cast<std::size_t>(bit)); + 44 : : } + 45 : 2364 : return bits; + 46 : : } + 47 : : + 48 : 71 : bool AreMutuallyExclusive(const DecodeSignal &first, const DecodeSignal &second) { + 49 : 96 : return first.multiplexing.role == MultiplexRole::Branch && + 50 [ + + + + ]: 77 : second.multiplexing.role == MultiplexRole::Branch && + 51 [ + + ]: 77 : first.multiplexing.value != second.multiplexing.value; + 52 : : } + 53 : : + 54 : 2447 : void ValidateFrame(const DecodeFrame &frame) { + 55 [ + + ]: 2447 : const std::uint32_t maximumId = frame.isExtended ? 0x1FFFFFFFU : 0x7FFU; + 56 [ + + ]: 2447 : if (frame.canId > maximumId) + 57 [ + - + - ]: 9 : throw std::invalid_argument("Invalid normalized CAN ID: " + std::to_string(frame.canId)); + 58 : : + 59 [ + + + + : 2438 : if (frame.hasPgn && (!frame.isExtended || frame.pgn != ExtractJ1939Pgn(frame.canId))) + + + + + ] + 60 [ + - + - ]: 3 : throw std::invalid_argument("Invalid J1939 PGN metadata: " + frame.name); + 61 : : + 62 : 2435 : std::unordered_set<std::string> names; + 63 : 2435 : const DecodeSignal *selector = nullptr; + 64 [ + + ]: 4820 : for (const DecodeSignal &signal: frame.signals) { + 65 [ + - + + ]: 2480 : if (!names.insert(signal.name).second) + 66 [ + - + - ]: 4 : throw std::invalid_argument("Duplicate runtime signal key: " + signal.name); + 67 [ + + ]: 2476 : ValidateSignal(signal, frame.dlc); + 68 [ + + ]: 2391 : if (signal.multiplexing.role == MultiplexRole::Selector) { + 69 [ + + + + ]: 35 : if (selector != nullptr || signal.valueType != ValueType::Unsigned) + 70 [ + - ]: 6 : throw std::invalid_argument("Multiplexing requires one unsigned selector per frame"); + 71 : 29 : selector = &signal; + 72 : : } + 73 : : } + 74 : : + 75 : 2340 : std::vector<SignalBits> layouts; + 76 [ + - ]: 2340 : layouts.reserve(frame.signals.size()); + 77 [ + + ]: 4696 : for (std::size_t index = 0U; index < frame.signals.size(); ++index) { + 78 : 2372 : const DecodeSignal &signal = frame.signals[index]; + 79 [ + + + + ]: 2372 : if (signal.multiplexing.role == MultiplexRole::Branch && + 80 : 27 : (selector == nullptr || + 81 [ + + + + ]: 27 : (selector->length < 64U && signal.multiplexing.value >= (std::uint64_t(1U) << selector->length)))) + 82 [ + - + - ]: 8 : throw std::invalid_argument("Missing selector or branch value outside selector range: " + signal.name); + 83 [ + - ]: 2364 : const SignalBits bits = GetSignalBits(signal); + 84 [ + + ]: 2427 : for (std::size_t previous = 0U; previous < index; ++previous) { + 85 [ + + + + : 71 : if (!AreMutuallyExclusive(signal, frame.signals[previous]) && (bits & layouts[previous]).any()) + + + ] + 86 [ + - + - ]: 8 : throw std::invalid_argument("Overlapping signals: " + signal.name); + 87 : : } + 88 [ + - ]: 2356 : layouts.push_back(bits); + 89 : : } + 90 : 2451 : } + 91 : : }// namespace + 92 : : + 93 : 2394 : DecodeDatabase::Storage::Storage(const std::vector<DecodeFrame> &definitions) + 94 : 2394 : : frames(definitions) { + 95 : : // Validate the complete snapshot before creating its lookup index. + 96 : 2394 : std::unordered_set<FrameKey, FrameKeyHasher> keys; + 97 [ + - ]: 2394 : keys.reserve(frames.size()); + 98 [ + + ]: 4713 : for (const DecodeFrame &frame: frames) { + 99 [ + + ]: 2447 : ValidateFrame(frame); + 100 [ + - + + ]: 2324 : if (!keys.insert(frame.GetKey()).second) + 101 [ + - ]: 5 : throw std::invalid_argument("Duplicate runtime frame key"); + 102 : : } + 103 [ + - ]: 2266 : frameIndexByKey.reserve(frames.size()); + 104 [ + + ]: 4580 : for (std::size_t index = 0U; index < frames.size(); ++index) { + 105 [ + - ]: 2314 : frameIndexByKey.emplace(frames[index].GetKey(), index); + 106 [ + + ]: 2314 : if (frames[index].hasPgn) + 107 [ + - + - ]: 21 : frameIndicesByPgn[frames[index].pgn].push_back(index); + 108 : : } + 109 : 2778 : } + 110 : : + 111 : 2394 : DecodeDatabase::DecodeDatabase(const std::vector<DecodeFrame> &frames) + 112 : 2394 : : storage(std::make_shared<const Storage>(frames)) { + 113 : 2266 : } + 114 : : + 115 : 76 : const std::vector<DecodeFrame> &DecodeDatabase::GetFrames() const { + 116 [ + + + - ]: 76 : static const std::vector<DecodeFrame> empty; + 117 [ + + ]: 76 : return storage ? storage->frames : empty; + 118 : : } + 119 : : + 120 : 6555 : std::shared_ptr<const DecodeFrame> DecodeDatabase::FindFrame(const FrameKey &key) const { + 121 [ + + ]: 6555 : if (!storage) + 122 : 16 : return nullptr; + 123 : : const std::unordered_map<FrameKey, std::size_t, FrameKeyHasher>::const_iterator it = + 124 [ + - ]: 6539 : storage->frameIndexByKey.find(key); + 125 [ + + ]: 6539 : if (it == storage->frameIndexByKey.end()) + 126 : 115 : return nullptr; + 127 : 6424 : return std::shared_ptr<const DecodeFrame>(storage, &storage->frames[it->second]); + 128 : : } + 129 : : + 130 : 116 : PgnLookupResult DecodeDatabase::FindFrameByPgn(std::uint32_t pgn) const { + 131 : 116 : PgnLookupResult result; + 132 [ + + ]: 116 : if (!storage) + 133 : 24 : return result; + 134 : : const std::unordered_map<std::uint32_t, std::vector<std::size_t>>::const_iterator it = + 135 [ + - ]: 92 : storage->frameIndicesByPgn.find(pgn); + 136 [ + + ]: 92 : if (it == storage->frameIndicesByPgn.end()) + 137 : 47 : return result; + 138 [ + + ]: 45 : if (it->second.size() != 1U) { + 139 : 16 : result.ambiguous = true; + 140 : 16 : return result; + 141 : : } + 142 : 29 : result.definition = std::shared_ptr<const DecodeFrame>(storage, &storage->frames[it->second[0]]); + 143 : 29 : return result; + 144 : 0 : } + 145 : : + 146 : 53 : std::shared_ptr<const DecodeSignal> DecodeDatabase::FindSignal(const SignalKey &key) const { + 147 [ + - ]: 53 : const std::shared_ptr<const DecodeFrame> frame = FindFrame(key.frame); + 148 [ + + ]: 53 : if (!frame) + 149 : 10 : return nullptr; + 150 [ + + ]: 53 : for (const DecodeSignal &signal: frame->signals) { + 151 [ + + ]: 48 : if (signal.name == key.name) + 152 : 38 : return std::shared_ptr<const DecodeSignal>(frame, &signal); + 153 : : } + 154 : 5 : return nullptr; + 155 : 53 : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DecodeDatabase::DecodeDatabase() | + +21 | + + + +
| DecodeFrame::DecodeFrame() | + +2400 | + + + +
| DecodeSignal::DecodeSignal() | + +2438 | + + + +
| DecodeFrame::GetKey() const | + +11038 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| DecodeDatabase::DecodeDatabase() | + +21 | + + + +
| DecodeFrame::DecodeFrame() | + +2400 | + + + +
| DecodeFrame::GetKey() const | + +11038 | + + + +
| DecodeSignal::DecodeSignal() | + +2438 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
+Line data Source code+ + 1 : /** + 2 : * @file decode_database.h + 3 : * @brief Runtime definitions and immutable indexed database. + 4 : * + 5 : * Created: 2026-03-13 + 6 : * Author: Deeaitch (Dim. Himro) + 7 : * + 8 : * Licensed under the MIT License. + 9 : * See LICENSE file in the project root for full license text. + 10 : */ + 11 : + 12 : #ifndef DECODE_DATABASE_H + 13 : #define DECODE_DATABASE_H + 14 : + 15 : #include "attributes.h" + 16 : #include "definition_key.h" + 17 : #include "multiplexing.h" + 18 : #include "value_descriptions.h" + 19 : #include <cstdint> + 20 : #include <memory> + 21 : #include <string> + 22 : #include <unordered_map> + 23 : #include <vector> + 24 : + 25 : /** + 26 : * @brief Signal byte order used for runtime decoding. + 27 : */ + 28 : enum class ByteOrder { + 29 : Intel, + 30 : Motorola + 31 : }; + 32 : + 33 : /** + 34 : * @brief Signal numeric type. + 35 : */ + 36 : enum class ValueType { + 37 : Unsigned, + 38 : Signed + 39 : }; + 40 : + 41 : /** + 42 : * @brief Runtime-ready signal definition. + 43 : */ + 44 : struct DecodeSignal { + 45 : Multiplexing multiplexing; /**< Selector role and branch value. */ + 46 : std::string name; /**< Signal name. */ + 47 : std::uint32_t startBit = 0U; /**< DBC start bit. */ + 48 : std::uint32_t length = 0U; /**< Signal length in bits. */ + 49 : ByteOrder byteOrder = ByteOrder::Intel; /**< Intel or Motorola. */ + 50 : ValueType valueType = ValueType::Unsigned; /**< Signed or unsigned. */ + 51 : double factor = 1.0; /**< Scaling factor. */ + 52 : double offset = 0.0; /**< Physical offset. */ + 53 : double minimum = 0.0; /**< Minimum physical value. */ + 54 : double maximum = 0.0; /**< Maximum physical value. */ + 55 : std::string unit; /**< Physical unit. */ + 56 : std::vector<std::string> receivers; /**< Receivers. */ + 57 : ValueDescriptions valueDescriptions; /**< Raw integer state descriptions. */ + 58 : std::string comment; /**< Comment. */ + 59 : + 60 : AttributeMap attributes; /**< Effective attributes after defaults and overrides. */ + 61 : + 62 2438 : DecodeSignal() = default; + 63 : }; + 64 : + 65 : /** + 66 : * @brief Runtime-ready frame definition. + 67 : */ + 68 : struct DecodeFrame { + 69 : std::string name; /**< Frame name. */ + 70 : std::uint32_t canId = 0U; /**< Normalized CAN ID. */ + 71 : bool isExtended = false; /**< true for extended frame. */ + 72 : std::uint8_t dlc = 0U; /**< Payload length. */ + 73 : std::uint32_t pgn = 0U; /**< PGN if available. */ + 74 : bool hasPgn = false; /**< Explicit J1939 opt-in; pgn must match canId. */ + 75 : std::string transmitter; /**< Transmitter ECU. */ + 76 : std::string comment; /**< Frame comment. */ + 77 : std::vector<DecodeSignal> signals; /**< Signal definitions. */ + 78 : + 79 : AttributeMap attributes; /**< Effective attributes after defaults and overrides. */ + 80 : std::optional<std::string> frameFormat; /**< VFrameFormat label, when declared. */ + 81 : std::optional<std::uint32_t> cycleTimeMs; /**< GenMsgCycleTime in milliseconds, when declared. */ + 82 : + 83 2400 : DecodeFrame() = default; + 84 : + 85 : /** @brief Return the stable normalized frame identifier. */ + 86 11038 : FrameKey GetKey() const { + 87 11038 : return FrameKey(canId, isExtended); + 88 : } + 89 : }; + 90 : + 91 : /** A PGN lookup rejects multiple definitions rather than choosing by order. */ + 92 : struct PgnLookupResult { + 93 : std::shared_ptr<const DecodeFrame> definition; /**< Owning matched definition; empty if missing or ambiguous. */ + 94 : bool ambiguous = false; /**< True when multiple definitions share the requested PGN. */ + 95 : }; + 96 : + 97 : /** + 98 : * @brief Immutable runtime snapshot. Copies share storage; reload replaces a snapshot. + 99 : * Owning lookup handles and decoded results keep old definitions alive. + 100 : */ + 101 : class DecodeDatabase { + 102 : public: + 103 21 : DecodeDatabase() = default; + 104 : /** + 105 : * Copy and validate definitions before building the frame index. + 106 : * Input aliases cannot modify the snapshot, even for rvalue input. + 107 : * @throws std::invalid_argument for invalid metadata or duplicate keys. + 108 : */ + 109 : explicit DecodeDatabase(const std::vector<DecodeFrame> &frames); + 110 : + 111 : /** Borrowed view, valid while this snapshot remains alive and unchanged. */ + 112 : const std::vector<DecodeFrame> &GetFrames() const; + 113 : /** Owning handles retain the entire snapshot across reload or destruction. */ + 114 : std::shared_ptr<const DecodeFrame> FindFrame(const FrameKey &key) const; + 115 : /** Only explicitly marked hasPgn frames participate; ambiguous results have no definition. */ + 116 : PgnLookupResult FindFrameByPgn(std::uint32_t pgn) const; + 117 : /** @brief Return an owning signal handle, or an empty handle for a missing key. */ + 118 : std::shared_ptr<const DecodeSignal> FindSignal(const SignalKey &key) const; + 119 : + 120 : private: + 121 : struct Storage { + 122 : std::vector<DecodeFrame> frames; + 123 : std::unordered_map<FrameKey, std::size_t, FrameKeyHasher> frameIndexByKey; + 124 : + 125 : std::unordered_map<std::uint32_t, std::vector<std::size_t>> frameIndicesByPgn; + 126 : + 127 : explicit Storage(const std::vector<DecodeFrame> &definitions); + 128 : }; + 129 : + 130 : std::shared_ptr<const Storage> storage; + 131 : }; + 132 : + 133 : #endif /* DECODE_DATABASE_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| SignalKeyHasher::operator()(SignalKey const&) const | + +9 | + + + +
| SignalKey::operator==(SignalKey const&) const | + +22 | + + + +
| SignalKey::SignalKey() | + +6380 | + + + +
| SignalKey::SignalKey(FrameKey, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) | + +6454 | + + + +
| FrameKey::operator==(FrameKey const&) const | + +6502 | + + + +
| FrameKeyHasher::operator()(FrameKey const&) const | + +11161 | + + + +
| FrameKey::FrameKey() | + +12789 | + + + +
| FrameKey::FrameKey(unsigned int, bool) | + +23974 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| FrameKey::FrameKey() | + +12789 | + + + +
| FrameKey::FrameKey(unsigned int, bool) | + +23974 | + + + +
| FrameKey::operator==(FrameKey const&) const | + +6502 | + + + +
| FrameKeyHasher::operator()(FrameKey const&) const | + +11161 | + + + +
| SignalKey::SignalKey() | + +6380 | + + + +
| SignalKey::SignalKey(FrameKey, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) | + +6454 | + + + +
| SignalKey::operator==(SignalKey const&) const | + +22 | + + + +
| SignalKeyHasher::operator()(SignalKey const&) const | + +9 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : // Copyright (c) 2026 Dim Himro + 3 : : + 4 : : #ifndef DEFINITION_KEY_H + 5 : : #define DEFINITION_KEY_H + 6 : : + 7 : : #include <cstdint> + 8 : : #include <functional> + 9 : : #include <string> + 10 : : #include <utility> + 11 : : + 12 : : /** + 13 : : * @brief Stable frame identifier: normalized CAN ID and frame type. + 14 : : */ + 15 : : struct FrameKey { + 16 : : std::uint32_t canId = 0U; /**< Normalized CAN identifier. */ + 17 : : bool isExtended = false; /**< True for extended CAN frames. */ + 18 : : + 19 : 12789 : FrameKey() = default; + 20 : : + 21 : : /** @brief Create a key from a normalized identifier and frame type. */ + 22 : 23974 : FrameKey(std::uint32_t id, bool extended) + 23 : 23974 : : canId(id), isExtended(extended) { + 24 : 23974 : } + 25 : : + 26 : : /** @brief Compare all logical identity fields. */ + 27 : 6502 : bool operator==(const FrameKey &other) const { + 28 [ + + + - ]: 6502 : return (canId == other.canId) && (isExtended == other.isExtended); + 29 : : } + 30 : : }; + 31 : : + 32 : : /** + 33 : : * @brief Hasher for frame key. + 34 : : */ + 35 : : struct FrameKeyHasher { + 36 : : /** @brief Hash the logical identity fields. */ + 37 : 11161 : std::size_t operator()(const FrameKey &key) const { + 38 : 11161 : const std::size_t a = static_cast<std::size_t>(key.canId); + 39 [ + + ]: 11161 : const std::size_t b = key.isExtended ? 1U : 0U; + 40 : 11161 : return (a * 1315423911U) ^ b; + 41 : : } + 42 : : }; + 43 : : + 44 : : /** Stable signal identifier within one logical DBC database. */ + 45 : : struct SignalKey { + 46 : : FrameKey frame; /**< Owning frame identity. */ + 47 : : std::string name; /**< Signal name within the frame. */ + 48 : : + 49 : 6380 : SignalKey() = default; + 50 : : /** @brief Create a signal key from its frame identity and name. */ + 51 : 6454 : SignalKey(FrameKey frameKey, std::string signalName) + 52 : 6454 : : frame(frameKey), name(std::move(signalName)) { + 53 : 6454 : } + 54 : : + 55 : : /** @brief Compare all logical identity fields. */ + 56 : 22 : bool operator==(const SignalKey &other) const { + 57 [ + - + - ]: 22 : return frame == other.frame && name == other.name; + 58 : : } + 59 : : }; + 60 : : + 61 : : /** @brief Hasher for stable signal keys. */ + 62 : : struct SignalKeyHasher { + 63 : : /** @brief Hash the logical identity fields. */ + 64 : 9 : std::size_t operator()(const SignalKey &key) const { + 65 : 9 : return FrameKeyHasher()(key.frame) ^ (std::hash<std::string>()(key.name) << 1U); + 66 : : } + 67 : : }; + 68 : : + 69 : : #endif /* DEFINITION_KEY_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| FrameInfo::FrameInfo() | + +716 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| FrameInfo::FrameInfo() | + +716 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
+Line data Source code+ + 1 : /** + 2 : * @file frame_info.h + 3 : * @brief Parsed CAN frame metadata. + 4 : * + 5 : * Created: 2026-03-13 + 6 : * Author: Deeaitch (Dim. Himro) + 7 : * + 8 : * Licensed under the MIT License. + 9 : * See LICENSE file in the project root for full license text. + 10 : */ + 11 : + 12 : #ifndef FRAME_INFO_H + 13 : #define FRAME_INFO_H + 14 : + 15 : #include "attributes.h" + 16 : #include <cstdint> + 17 : #include <string> + 18 : #include <vector> + 19 : + 20 : #include "signal_info.h" + 21 : + 22 : /** + 23 : * @brief Describes one CAN frame from a DBC file. + 24 : */ + 25 : struct FrameInfo { + 26 : std::string name; /**< Frame name. */ + 27 : std::uint32_t canId = 0U; /**< Normalized CAN identifier. */ + 28 : bool isExtended = false; /**< true for extended frame. */ + 29 : std::uint32_t pgn = 0U; /**< J1939 PGN if applicable. */ + 30 : bool hasPgn = false; /**< Explicit J1939 opt-in; pgn is derived from canId. */ + 31 : std::uint8_t dlc = 0U; /**< Frame payload length. */ + 32 : std::string transmitter; /**< Transmitter ECU name. */ + 33 : std::string comment; /**< Optional frame comment. */ + 34 : std::vector<SignalInfo> signals; /**< Signals contained in the frame. */ + 35 : + 36 : std::optional<std::string> frameFormat; /**< VFrameFormat label, when declared. */ /**< VFrameFormat enum label. */ + 37 : std::optional<std::uint32_t> cycleTimeMs; /**< GenMsgCycleTime in milliseconds, when declared. */ /**< GenMsgCycleTime; zero means unspecified. */ + 38 : + 39 : AttributeMap attributes; /**< Effective attributes after defaults and overrides. */ /**< Effective values, including defaults. */ + 40 : + 41 716 : FrameInfo() = default; + 42 : }; + 43 : + 44 : #endif /* FRAME_INFO_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| File |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| dbc_parser.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| decode_database.h | +
+
|
+ 100.0 % | +5 | +5 | +- | ++ | + | 100.0 % | +4 | +4 | +|
| frame_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| signal_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| tree_node.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| dbc_statement_handler.h | +
+
|
+ 100.0 % | +8 | +8 | +45.5 % | +22 | +10 | +100.0 % | +10 | +10 | +|
| typefactory.h | +
+
|
+ 100.0 % | +12 | +12 | +50.0 % | +8 | +4 | +100.0 % | +27 | +27 | +|
| dbc_decode_builder.cpp | +
+
|
+ 100.0 % | +40 | +40 | +62.5 % | +40 | +25 | +100.0 % | +1 | +1 | +|
| dbc_tree_builder.cpp | +
+
|
+ 91.7 % | +12 | +11 | +66.7 % | +12 | +8 | +100.0 % | +1 | +1 | +|
| dbc_statement_handler.cpp | +
+
|
+ 99.5 % | +370 | +368 | +68.4 % | +820 | +561 | +100.0 % | +31 | +31 | +|
| definition_key.h | +
+
|
+ 100.0 % | +18 | +18 | +70.0 % | +10 | +7 | +100.0 % | +8 | +8 | +|
| dbc_parser.cpp | +
+
|
+ 99.0 % | +99 | +98 | +70.4 % | +216 | +152 | +100.0 % | +4 | +4 | +|
| dbc_decoder.cpp | +
+
|
+ 94.9 % | +156 | +148 | +72.8 % | +158 | +115 | +100.0 % | +12 | +12 | +|
| dbc_attributes.cpp | +
+
|
+ 98.8 % | +260 | +257 | +73.5 % | +604 | +444 | +100.0 % | +20 | +20 | +|
| dbc_decoder.h | +
+
|
+ 100.0 % | +5 | +5 | +75.0 % | +4 | +3 | +100.0 % | +4 | +4 | +|
| tree_node.cpp | +
+
|
+ 98.1 % | +53 | +52 | +76.2 % | +42 | +32 | +100.0 % | +15 | +15 | +|
| decode_database.cpp | +
+
|
+ 99.1 % | +110 | +109 | +80.2 % | +182 | +146 | +100.0 % | +10 | +10 | +|
| value_descriptions.h | +
+
|
+ 100.0 % | +8 | +8 | +87.5 % | +8 | +7 | +100.0 % | +2 | +2 | +|
| j1939.h | +
+
|
+ 100.0 % | +4 | +4 | +100.0 % | +2 | +2 | +100.0 % | +1 | +1 | +|
| dbc_diagnostic.h | +
+
|
+ 100.0 % | +5 | +5 | +100.0 % | +4 | +4 | +100.0 % | +1 | +1 | +|
| signal_layout.h | +
+
|
+ 100.0 % | +6 | +6 | +100.0 % | +8 | +8 | +100.0 % | +2 | +2 | +|
| text_utils.h | +
+
|
+ 100.0 % | +10 | +10 | +100.0 % | +12 | +12 | +100.0 % | +1 | +1 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| File |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| dbc_decode_builder.cpp | +
+
|
+ 100.0 % | +40 | +40 | +62.5 % | +40 | +25 | +100.0 % | +1 | +1 | +|
| dbc_diagnostic.h | +
+
|
+ 100.0 % | +5 | +5 | +100.0 % | +4 | +4 | +100.0 % | +1 | +1 | +|
| dbc_parser.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| dbc_tree_builder.cpp | +
+
|
+ 91.7 % | +12 | +11 | +66.7 % | +12 | +8 | +100.0 % | +1 | +1 | +|
| frame_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| j1939.h | +
+
|
+ 100.0 % | +4 | +4 | +100.0 % | +2 | +2 | +100.0 % | +1 | +1 | +|
| signal_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| text_utils.h | +
+
|
+ 100.0 % | +10 | +10 | +100.0 % | +12 | +12 | +100.0 % | +1 | +1 | +|
| tree_node.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| signal_layout.h | +
+
|
+ 100.0 % | +6 | +6 | +100.0 % | +8 | +8 | +100.0 % | +2 | +2 | +|
| value_descriptions.h | +
+
|
+ 100.0 % | +8 | +8 | +87.5 % | +8 | +7 | +100.0 % | +2 | +2 | +|
| dbc_decoder.h | +
+
|
+ 100.0 % | +5 | +5 | +75.0 % | +4 | +3 | +100.0 % | +4 | +4 | +|
| dbc_parser.cpp | +
+
|
+ 99.0 % | +99 | +98 | +70.4 % | +216 | +152 | +100.0 % | +4 | +4 | +|
| decode_database.h | +
+
|
+ 100.0 % | +5 | +5 | +- | ++ | + | 100.0 % | +4 | +4 | +|
| definition_key.h | +
+
|
+ 100.0 % | +18 | +18 | +70.0 % | +10 | +7 | +100.0 % | +8 | +8 | +|
| dbc_statement_handler.h | +
+
|
+ 100.0 % | +8 | +8 | +45.5 % | +22 | +10 | +100.0 % | +10 | +10 | +|
| decode_database.cpp | +
+
|
+ 99.1 % | +110 | +109 | +80.2 % | +182 | +146 | +100.0 % | +10 | +10 | +|
| dbc_decoder.cpp | +
+
|
+ 94.9 % | +156 | +148 | +72.8 % | +158 | +115 | +100.0 % | +12 | +12 | +|
| tree_node.cpp | +
+
|
+ 98.1 % | +53 | +52 | +76.2 % | +42 | +32 | +100.0 % | +15 | +15 | +|
| dbc_attributes.cpp | +
+
|
+ 98.8 % | +260 | +257 | +73.5 % | +604 | +444 | +100.0 % | +20 | +20 | +|
| typefactory.h | +
+
|
+ 100.0 % | +12 | +12 | +50.0 % | +8 | +4 | +100.0 % | +27 | +27 | +|
| dbc_statement_handler.cpp | +
+
|
+ 99.5 % | +370 | +368 | +68.4 % | +820 | +561 | +100.0 % | +31 | +31 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| File |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| dbc_tree_builder.cpp | +
+
|
+ 91.7 % | +12 | +11 | +66.7 % | +12 | +8 | +100.0 % | +1 | +1 | +|
| dbc_decoder.cpp | +
+
|
+ 94.9 % | +156 | +148 | +72.8 % | +158 | +115 | +100.0 % | +12 | +12 | +|
| tree_node.cpp | +
+
|
+ 98.1 % | +53 | +52 | +76.2 % | +42 | +32 | +100.0 % | +15 | +15 | +|
| dbc_attributes.cpp | +
+
|
+ 98.8 % | +260 | +257 | +73.5 % | +604 | +444 | +100.0 % | +20 | +20 | +|
| dbc_parser.cpp | +
+
|
+ 99.0 % | +99 | +98 | +70.4 % | +216 | +152 | +100.0 % | +4 | +4 | +|
| decode_database.cpp | +
+
|
+ 99.1 % | +110 | +109 | +80.2 % | +182 | +146 | +100.0 % | +10 | +10 | +|
| dbc_statement_handler.cpp | +
+
|
+ 99.5 % | +370 | +368 | +68.4 % | +820 | +561 | +100.0 % | +31 | +31 | +|
| dbc_parser.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| frame_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| signal_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| tree_node.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| j1939.h | +
+
|
+ 100.0 % | +4 | +4 | +100.0 % | +2 | +2 | +100.0 % | +1 | +1 | +|
| dbc_decoder.h | +
+
|
+ 100.0 % | +5 | +5 | +75.0 % | +4 | +3 | +100.0 % | +4 | +4 | +|
| dbc_diagnostic.h | +
+
|
+ 100.0 % | +5 | +5 | +100.0 % | +4 | +4 | +100.0 % | +1 | +1 | +|
| decode_database.h | +
+
|
+ 100.0 % | +5 | +5 | +- | ++ | + | 100.0 % | +4 | +4 | +|
| signal_layout.h | +
+
|
+ 100.0 % | +6 | +6 | +100.0 % | +8 | +8 | +100.0 % | +2 | +2 | +|
| dbc_statement_handler.h | +
+
|
+ 100.0 % | +8 | +8 | +45.5 % | +22 | +10 | +100.0 % | +10 | +10 | +|
| value_descriptions.h | +
+
|
+ 100.0 % | +8 | +8 | +87.5 % | +8 | +7 | +100.0 % | +2 | +2 | +|
| text_utils.h | +
+
|
+ 100.0 % | +10 | +10 | +100.0 % | +12 | +12 | +100.0 % | +1 | +1 | +|
| typefactory.h | +
+
|
+ 100.0 % | +12 | +12 | +50.0 % | +8 | +4 | +100.0 % | +27 | +27 | +|
| definition_key.h | +
+
|
+ 100.0 % | +18 | +18 | +70.0 % | +10 | +7 | +100.0 % | +8 | +8 | +|
| dbc_decode_builder.cpp | +
+
|
+ 100.0 % | +40 | +40 | +62.5 % | +40 | +25 | +100.0 % | +1 | +1 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| File |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| dbc_attributes.cpp | +
+
|
+ 98.8 % | +260 | +257 | +73.5 % | +604 | +444 | +100.0 % | +20 | +20 | +|
| dbc_decode_builder.cpp | +
+
|
+ 100.0 % | +40 | +40 | +62.5 % | +40 | +25 | +100.0 % | +1 | +1 | +|
| dbc_decoder.cpp | +
+
|
+ 94.9 % | +156 | +148 | +72.8 % | +158 | +115 | +100.0 % | +12 | +12 | +|
| dbc_decoder.h | +
+
|
+ 100.0 % | +5 | +5 | +75.0 % | +4 | +3 | +100.0 % | +4 | +4 | +|
| dbc_diagnostic.h | +
+
|
+ 100.0 % | +5 | +5 | +100.0 % | +4 | +4 | +100.0 % | +1 | +1 | +|
| dbc_parser.cpp | +
+
|
+ 99.0 % | +99 | +98 | +70.4 % | +216 | +152 | +100.0 % | +4 | +4 | +|
| dbc_parser.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| dbc_statement_handler.cpp | +
+
|
+ 99.5 % | +370 | +368 | +68.4 % | +820 | +561 | +100.0 % | +31 | +31 | +|
| dbc_statement_handler.h | +
+
|
+ 100.0 % | +8 | +8 | +45.5 % | +22 | +10 | +100.0 % | +10 | +10 | +|
| dbc_tree_builder.cpp | +
+
|
+ 91.7 % | +12 | +11 | +66.7 % | +12 | +8 | +100.0 % | +1 | +1 | +|
| decode_database.cpp | +
+
|
+ 99.1 % | +110 | +109 | +80.2 % | +182 | +146 | +100.0 % | +10 | +10 | +|
| decode_database.h | +
+
|
+ 100.0 % | +5 | +5 | +- | ++ | + | 100.0 % | +4 | +4 | +|
| definition_key.h | +
+
|
+ 100.0 % | +18 | +18 | +70.0 % | +10 | +7 | +100.0 % | +8 | +8 | +|
| frame_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| j1939.h | +
+
|
+ 100.0 % | +4 | +4 | +100.0 % | +2 | +2 | +100.0 % | +1 | +1 | +|
| signal_info.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| signal_layout.h | +
+
|
+ 100.0 % | +6 | +6 | +100.0 % | +8 | +8 | +100.0 % | +2 | +2 | +|
| text_utils.h | +
+
|
+ 100.0 % | +10 | +10 | +100.0 % | +12 | +12 | +100.0 % | +1 | +1 | +|
| tree_node.cpp | +
+
|
+ 98.1 % | +53 | +52 | +76.2 % | +42 | +32 | +100.0 % | +15 | +15 | +|
| tree_node.h | +
+
|
+ 100.0 % | +1 | +1 | +- | ++ | + | 100.0 % | +1 | +1 | +|
| typefactory.h | +
+
|
+ 100.0 % | +12 | +12 | +50.0 % | +8 | +4 | +100.0 % | +27 | +27 | +|
| value_descriptions.h | +
+
|
+ 100.0 % | +8 | +8 | +87.5 % | +8 | +7 | +100.0 % | +2 | +2 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| ExtractJ1939Pgn(unsigned int) | + +130 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| ExtractJ1939Pgn(unsigned int) | + +130 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #ifndef J1939_H + 3 : : #define J1939_H + 4 : : + 5 : : #include <cstdint> + 6 : : + 7 : : /** Extract an 18-bit PGN from a normalized 29-bit ID explicitly interpreted as J1939. + 8 : : * Priority and source address are excluded. PDU1 also excludes destination address. + 9 : : * Both data-page bits are retained; this does not validate the J1939 protocol. + 10 : : */ + 11 : 130 : inline std::uint32_t ExtractJ1939Pgn(std::uint32_t canId) { + 12 : 130 : const std::uint32_t pf = (canId >> 16U) & 0xFFU; + 13 : 130 : const std::uint32_t pgn = (canId >> 8U) & 0x3FFFFU; + 14 [ + + ]: 130 : return pf < 240U ? pgn & 0x3FF00U : pgn; + 15 : : } + 16 : : + 17 : : #endif /* J1939_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| SignalInfo::SignalInfo() | + +592 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| SignalInfo::SignalInfo() | + +592 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
+Line data Source code+ + 1 : /** + 2 : * @file signal_info.h + 3 : * @brief Parsed CAN signal metadata. + 4 : * + 5 : * Created: 2026-03-13 + 6 : * Author: Deeaitch (Dim. Himro) + 7 : * + 8 : * Licensed under the MIT License. + 9 : * See LICENSE file in the project root for full license text. + 10 : */ + 11 : + 12 : #ifndef SIGNAL_INFO_H + 13 : #define SIGNAL_INFO_H + 14 : + 15 : #include "attributes.h" + 16 : #include "multiplexing.h" + 17 : #include "value_descriptions.h" + 18 : #include <cstdint> + 19 : #include <string> + 20 : #include <vector> + 21 : + 22 : /** + 23 : * @brief Describes one signal inside a DBC frame. + 24 : */ + 25 : struct SignalInfo { + 26 : Multiplexing multiplexing; /**< Selector role and branch value. */ + 27 : std::string name; /**< Signal name. */ + 28 : std::uint32_t startBit = 0U; /**< Start bit in DBC notation. */ + 29 : std::uint32_t length = 0U; /**< Signal length in bits. */ + 30 : bool isLittleEndian = true; /**< true for Intel, false for Motorola. */ + 31 : bool isSigned = false; /**< true if signal is signed. */ + 32 : double factor = 1.0; /**< Scaling factor. */ + 33 : double offset = 0.0; /**< Physical offset. */ + 34 : double minimum = 0.0; /**< Minimum physical value. */ + 35 : double maximum = 0.0; /**< Maximum physical value. */ + 36 : std::string unit; /**< Physical unit. */ + 37 : std::vector<std::string> receivers; /**< Signal receivers. */ + 38 : ValueDescriptions valueDescriptions; /**< Raw integer state descriptions. */ + 39 : std::string comment; /**< Optional signal comment. */ + 40 : + 41 : AttributeMap attributes; /**< Effective attributes after defaults and overrides. */ /**< Effective values, including defaults. */ + 42 : + 43 592 : SignalInfo() = default; + 44 : }; + 45 : + 46 : #endif /* SIGNAL_INFO_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| SignalStartCoordinate(unsigned int, bool) | + +352521 | + + + +
| IsValidSignalLayout(unsigned int, unsigned int, bool, unsigned char) | + +360851 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| IsValidSignalLayout(unsigned int, unsigned int, bool, unsigned char) | + +360851 | + + + +
| SignalStartCoordinate(unsigned int, bool) | + +352521 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #ifndef SIGNAL_LAYOUT_H + 3 : : #define SIGNAL_LAYOUT_H + 4 : : + 5 : : #include <cstdint> + 6 : : + 7 : : /** Linear coordinate in the signal's bit order, widened before arithmetic. */ + 8 : 352521 : inline std::uint64_t SignalStartCoordinate(std::uint32_t startBit, bool littleEndian) { + 9 [ + + ]: 352521 : return littleEndian ? std::uint64_t(startBit) + 10 : 352521 : : std::uint64_t(startBit / 8U) * 8U + 7U - startBit % 8U; + 11 : : } + 12 : : + 13 : 360851 : inline bool IsValidSignalLayout(std::uint32_t startBit, std::uint32_t length, + 14 : : bool littleEndian, std::uint8_t dlc) { + 15 [ + + + + ]: 711008 : return length >= 1U && length <= 64U && + 16 [ + + ]: 711008 : SignalStartCoordinate(startBit, littleEndian) + length <= std::uint64_t(dlc) * 8U; + 17 : : } + 18 : : + 19 : : #endif ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| dbc_detail::TrimText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) | + +2913 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| dbc_detail::TrimText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) | + +2913 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : #ifndef DBC_TEXT_UTILS_H + 2 : : #define DBC_TEXT_UTILS_H + 3 : : + 4 : : #include <cctype> + 5 : : #include <string> + 6 : : + 7 : : namespace dbc_detail { + 8 : 2913 : inline std::string TrimText(const std::string &text) { + 9 : 2913 : std::string::size_type begin = 0U; + 10 [ + + + + ]: 5727 : while ((begin < text.size()) && + 11 [ + + ]: 2692 : std::isspace(static_cast<unsigned char>(text[begin]))) + 12 : 122 : ++begin; + 13 : : + 14 : 2913 : std::string::size_type end = text.size(); + 15 [ + + + + ]: 5491 : while ((end > begin) && + 16 [ + + ]: 2574 : std::isspace(static_cast<unsigned char>(text[end - 1U]))) + 17 : 4 : --end; + 18 : : + 19 : 2913 : return text.substr(begin, end - begin); + 20 : : } + 21 : : } + 22 : : + 23 : : #endif ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| TreeNode::GetSignalKey() const | + +9 | + + + +
| TreeNode::TreeNode() | + +22 | + + + +
| TreeNode::GetFrameKey() const | + +23 | + + + +
| TreeNode::GetName[abi:cxx11]() const | + +29 | + + + +
| TreeNode::GetType() const | + +44 | + + + +
| TreeNode::GetChild(unsigned long) | + +91 | + + + +
| TreeNode::TreeNode(FrameInfo const&) | + +97 | + + + +
| TreeNode::TreeNode(SignalInfo const&) | + +110 | + + + +
| TreeNode::AddChild(std::unique_ptr<TreeNode, std::default_delete<TreeNode> >&&) | + +206 | + + + +
| TreeNode::GetFrame() const | + +274 | + + + +
| TreeNode::GetSignal() const | + +281 | + + + +
| TreeNode::GetRow() const | + +1547 | + + + +
| TreeNode::GetParent() const | + +1875 | + + + +
| TreeNode::GetChildCount() const | + +2120 | + + + +
| TreeNode::GetChild(unsigned long) const | + +3430 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| TreeNode::AddChild(std::unique_ptr<TreeNode, std::default_delete<TreeNode> >&&) | + +206 | + + + +
| TreeNode::GetChild(unsigned long) | + +91 | + + + +
| TreeNode::GetChild(unsigned long) const | + +3430 | + + + +
| TreeNode::GetChildCount() const | + +2120 | + + + +
| TreeNode::GetFrame() const | + +274 | + + + +
| TreeNode::GetFrameKey() const | + +23 | + + + +
| TreeNode::GetName[abi:cxx11]() const | + +29 | + + + +
| TreeNode::GetParent() const | + +1875 | + + + +
| TreeNode::GetRow() const | + +1547 | + + + +
| TreeNode::GetSignal() const | + +281 | + + + +
| TreeNode::GetSignalKey() const | + +9 | + + + +
| TreeNode::GetType() const | + +44 | + + + +
| TreeNode::TreeNode() | + +22 | + + + +
| TreeNode::TreeNode(FrameInfo const&) | + +97 | + + + +
| TreeNode::TreeNode(SignalInfo const&) | + +110 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : /** + 2 : : * @file tree_node.cpp + 3 : : * @brief Tree node ownership and navigation. + 4 : : * + 5 : : * Created: 2026-03-13 + 6 : : * Author: Deeaitch (Dim. Himro) + 7 : : * + 8 : : * Licensed under the MIT License. + 9 : : * See LICENSE file in the project root for full license text. + 10 : : */ + 11 : : + 12 : : #include "tree_node.h" + 13 : : #include <stdexcept> + 14 : : + 15 : 22 : TreeNode::TreeNode() + 16 [ + - ]: 66 : : m_type(NodeType::Root), m_name("dbc") { + 17 : 22 : } + 18 : : + 19 : 97 : TreeNode::TreeNode(const FrameInfo &frame) + 20 [ + - ]: 97 : : m_type(NodeType::Frame), m_name(frame.name), m_frame(std::make_unique<FrameInfo>(frame)) { + 21 : 97 : } + 22 : : + 23 : 110 : TreeNode::TreeNode(const SignalInfo &signal) + 24 [ + - ]: 110 : : m_type(NodeType::Signal), m_name(signal.name), m_signal(std::make_unique<SignalInfo>(signal)) { + 25 : 110 : } + 26 : : + 27 : 206 : void TreeNode::AddChild(std::unique_ptr<TreeNode> &&child) { + 28 [ + + ]: 206 : if (child) { + 29 [ + + ]: 474 : for (const TreeNode *ancestor = this; ancestor; ancestor = ancestor->m_parent) { + 30 [ + + ]: 271 : if (ancestor == child.get()) + 31 [ + - ]: 2 : throw std::invalid_argument("Cannot insert a node into its own subtree"); + 32 : : } + 33 [ - + ]: 203 : if (child->m_parent) + 34 [ # # ]: 0 : throw std::invalid_argument("Child is already attached"); + 35 : 203 : m_children.push_back(std::move(child)); + 36 : 203 : m_children.back()->m_parent = this; + 37 : 203 : m_children.back()->m_row = m_children.size() - 1U; + 38 : : } + 39 : 204 : } + 40 : : + 41 : 2120 : std::size_t TreeNode::GetChildCount() const { + 42 : 2120 : return m_children.size(); + 43 : : } + 44 : : + 45 : 3430 : const TreeNode *TreeNode::GetChild(std::size_t index) const { + 46 [ + + ]: 3430 : if (index >= m_children.size()) + 47 : 1107 : return nullptr; + 48 : : + 49 : 2323 : return m_children[index].get(); + 50 : : } + 51 : : + 52 : 91 : TreeNode *TreeNode::GetChild(std::size_t index) { + 53 [ + + ]: 91 : if (index >= m_children.size()) + 54 : 2 : return nullptr; + 55 : : + 56 : 89 : return m_children[index].get(); + 57 : : } + 58 : : + 59 : 44 : NodeType TreeNode::GetType() const { + 60 : 44 : return m_type; + 61 : : } + 62 : : + 63 : 29 : const std::string &TreeNode::GetName() const { + 64 : 29 : return m_name; + 65 : : } + 66 : : + 67 : 274 : const FrameInfo *TreeNode::GetFrame() const { + 68 : 274 : return m_frame.get(); + 69 : : } + 70 : : + 71 : 281 : const SignalInfo *TreeNode::GetSignal() const { + 72 : 281 : return m_signal.get(); + 73 : : } + 74 : : + 75 : 1875 : const TreeNode *TreeNode::GetParent() const { + 76 : 1875 : return m_parent; + 77 : : } + 78 : : + 79 : 1547 : std::size_t TreeNode::GetRow() const { + 80 : 1547 : return m_row; + 81 : : } + 82 : : + 83 : 23 : std::optional<FrameKey> TreeNode::GetFrameKey() const { + 84 [ + + ]: 23 : if (m_frame) + 85 : 13 : return FrameKey(m_frame->canId, m_frame->isExtended); + 86 [ + + + + : 10 : if (m_signal && m_parent && m_parent->GetType() == NodeType::Frame) + + - + + ] + 87 : 6 : return m_parent->GetFrameKey(); + 88 : 4 : return std::nullopt; + 89 : : } + 90 : : + 91 : 9 : std::optional<SignalKey> TreeNode::GetSignalKey() const { + 92 [ + - ]: 9 : const std::optional<FrameKey> frame = GetFrameKey(); + 93 [ + + + + : 9 : if (m_signal && frame) + + + ] + 94 [ + - ]: 5 : return SignalKey(*frame, m_signal->name); + 95 : 4 : return std::nullopt; + 96 : : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| TreeNode::~TreeNode() | + +229 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
| Function Name |
+
+ Hit count |
+
+
+
+
| TreeNode::~TreeNode() | + +229 | + + + +
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | ||||||||||||||||||||||
| ||||||||||||||||||||||
+
|
+ ||||||||||||||||||||||
|
+Line data Source code+ + 1 : /** + 2 : * @file tree_node.h + 3 : * @brief Qt-independent metadata tree nodes. + 4 : * + 5 : * Created: 2026-03-13 + 6 : * Author: Deeaitch (Dim. Himro) + 7 : * + 8 : * Licensed under the MIT License. + 9 : * See LICENSE file in the project root for full license text. + 10 : */ + 11 : + 12 : #ifndef TREE_NODE_H + 13 : #define TREE_NODE_H + 14 : + 15 : #include <cstddef> + 16 : #include <memory> + 17 : #include <optional> + 18 : #include <string> + 19 : #include <vector> + 20 : + 21 : #include "definition_key.h" + 22 : #include "frame_info.h" + 23 : #include "signal_info.h" + 24 : + 25 : /** + 26 : * @brief Type of a tree node. + 27 : */ + 28 : enum class NodeType { + 29 : Root, + 30 : Frame, + 31 : Signal + 32 : }; + 33 : + 34 : /** + 35 : * @brief Tree node for later use in model/view or other hierarchy consumers. + 36 : */ + 37 : class TreeNode { + 38 : public: + 39 : /** + 40 : * @brief Create root node. + 41 : */ + 42 : TreeNode(); + 43 : + 44 : /** + 45 : * @brief Create frame node. + 46 : * @param frame Frame payload. + 47 : */ + 48 : explicit TreeNode(const FrameInfo &frame); + 49 : + 50 : /** + 51 : * @brief Create signal node. + 52 : * @param signal Signal payload. + 53 : */ + 54 : explicit TreeNode(const SignalInfo &signal); + 55 : + 56 229 : ~TreeNode() = default; + 57 : + 58 : TreeNode(const TreeNode &) = delete; + 59 : TreeNode &operator=(const TreeNode &) = delete; + 60 : + 61 : // Node addresses are stable. Transfer unique_ptr ownership instead of nodes. + 62 : TreeNode(TreeNode &&) = delete; + 63 : TreeNode &operator=(TreeNode &&) = delete; + 64 : + 65 : /** + 66 : * @brief Add child node. + 67 : * @param child Child node to add. + 68 : * A null child is ignored. Existing children keep their addresses and rows. + 69 : * Ownership must be exclusive; attached nodes cannot be reparented. + 70 : * @throws std::invalid_argument for self/ancestor insertion or an attached child. + 71 : * Rejected ownership remains with the caller. + 72 : */ + 73 : void AddChild(std::unique_ptr<TreeNode> &&child); + 74 : + 75 : /** Non-owning parent; nullptr for a detached node or the root. */ + 76 : const TreeNode *GetParent() const; + 77 : + 78 : /** Zero-based sibling position; zero for a detached node or the root. */ + 79 : std::size_t GetRow() const; + 80 : + 81 : /** Frame identity for frame nodes and signals attached to a frame; otherwise empty. */ + 82 : std::optional<FrameKey> GetFrameKey() const; + 83 : + 84 : /** Signal identity (owning frame key and name); empty for other/detached nodes. */ + 85 : std::optional<SignalKey> GetSignalKey() const; + 86 : + 87 : /** + 88 : * @brief Get child count. + 89 : * @return Number of children. + 90 : */ + 91 : std::size_t GetChildCount() const; + 92 : + 93 : /** + 94 : * @brief Get child by index. + 95 : * @param index Child index. + 96 : * @return Child pointer or nullptr if index is invalid. + 97 : */ + 98 : const TreeNode *GetChild(std::size_t index) const; + 99 : + 100 : /** + 101 : * @brief Get mutable child by index. + 102 : * @param index Child index. + 103 : * @return Child pointer or nullptr if index is invalid. + 104 : */ + 105 : TreeNode *GetChild(std::size_t index); + 106 : + 107 : /** + 108 : * @brief Get node type. + 109 : * @return Node type. + 110 : */ + 111 : NodeType GetType() const; + 112 : + 113 : /** + 114 : * @brief Get display name. + 115 : * @return Node name. + 116 : */ + 117 : const std::string &GetName() const; + 118 : + 119 : /** + 120 : * @brief Get frame payload if node is frame. + 121 : * @return Pointer to frame info or nullptr. + 122 : */ + 123 : const FrameInfo *GetFrame() const; + 124 : + 125 : /** + 126 : * @brief Get signal payload if node is signal. + 127 : * @return Pointer to signal info or nullptr. + 128 : */ + 129 : const SignalInfo *GetSignal() const; + 130 : + 131 : private: + 132 : TreeNode *m_parent = nullptr; + 133 : std::size_t m_row = 0U; + 134 : NodeType m_type; + 135 : std::string m_name; + 136 : std::vector<std::unique_ptr<TreeNode>> m_children; + 137 : std::unique_ptr<FrameInfo> m_frame; + 138 : std::unique_ptr<SignalInfo> m_signal; + 139 : }; + 140 : + 141 : #endif /* TREE_NODE_H */ ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : // Copyright (c) 2026 Dim Himro + 3 : : + 4 : : #ifndef TYPEFACTORY_H + 5 : : #define TYPEFACTORY_H + 6 : : + 7 : : #include <memory> + 8 : : #include <type_traits> + 9 : : #include <unordered_map> + 10 : : #include <utility>// std::move + 11 : : + 12 : : /** + 13 : : * @brief Registry-based factory for creating objects by runtime identifier. + 14 : : * + 15 : : * Allows registering derived types and instantiating them using a ClassId key. + 16 : : * + 17 : : * Notes: + 18 : : * - Not thread-safe. Register types during initialization phase only. + 19 : : * - Re-registering the same id overwrites the previous entry ("last wins"). + 20 : : * - ClassId must be hashable (std::hash<ClassId> specialization must exist). + 21 : : * + 22 : : * @tparam ClassId Unique class identifier type (e.g. std::string, int, enum). + 23 : : * @tparam BaseClass Base type for all created objects. + 24 : : * @tparam Args Constructor arguments forwarded to registered derived types (by value). + 25 : : * + 26 : : * Usage example: + 27 : : * @code + 28 : : * #include <string> + 29 : : * + 30 : : * struct Base { + 31 : : * virtual ~Base() = default; + 32 : : * virtual int get() = 0; + 33 : : * }; + 34 : : * + 35 : : * struct Derived1 : Base { + 36 : : * explicit Derived1(int start) : m_start(start) {} + 37 : : * int get() override { return m_start + 1; } + 38 : : * int m_start = 0; + 39 : : * }; + 40 : : * + 41 : : * struct Derived2 : Base { + 42 : : * explicit Derived2(int start) : m_start(start) {} + 43 : : * int get() override { return m_start + 2; } + 44 : : * int m_start = 0; + 45 : : * }; + 46 : : * + 47 : : * TypeFactory<std::string, Base, int> factory; + 48 : : * factory.registerType<Derived1>("one"); + 49 : : * factory.registerType<Derived2>("two"); + 50 : : * + 51 : : * std::shared_ptr<Base> a = factory.create("one", 10); + 52 : : * std::shared_ptr<Base> b = factory.creator("two")(10); // advanced API: get creator function + 53 : : * + 54 : : * (void)a->get(); + 55 : : * (void)b->get(); + 56 : : * @endcode + 57 : : */ + 58 : : template<class ClassId, class BaseClass, class... Args> + 59 : : class TypeFactory { + 60 : : public: + 61 : : /** @brief Shared ownership handle returned for created instances. */ + 62 : : using BasePtr = std::shared_ptr<BaseClass>; + 63 : : /** @brief Registered creator function signature. */ + 64 : : using CreatorFn = BasePtr (*)(Args...); + 65 : : + 66 : 950 : TypeFactory() = default; + 67 : : + 68 : : /** + 69 : : * @brief Registers a Derived type under the given id. + 70 : : * + 71 : : * Requirements (checked at compile-time): + 72 : : * - Derived must inherit from BaseClass + 73 : : * - Derived must be constructible from Args... + 74 : : * + 75 : : * Re-registering the same id overwrites the previous entry ("last wins"). + 76 : : */ + 77 : : template<class Derived> + 78 : 14238 : void registerType(const ClassId &id) { + 79 : : static_assert(std::is_base_of_v<BaseClass, Derived>, + 80 : : "Derived must inherit from BaseClass"); + 81 : : static_assert(std::is_constructible_v<Derived, Args...>, + 82 : : "Derived must be constructible from Args..."); + 83 : : + 84 [ + - ]: 14238 : classes.insert_or_assign(id, &instantiate<Derived>); + 85 : 14238 : } + 86 : : + 87 : : /** + 88 : : * @brief Returns creator function for the given id. + 89 : : * @throws std::out_of_range when id is not registered. + 90 : : */ + 91 : 14241 : [[nodiscard]] CreatorFn creator(const ClassId &id) const { + 92 : 14241 : return classes.at(id); + 93 : : } + 94 : : + 95 : : /** + 96 : : * @brief Creates an instance for the given id using provided arguments. + 97 : : * @throws std::out_of_range when id is not registered. + 98 : : */ + 99 : 14239 : [[nodiscard]] BasePtr create(const ClassId &id, Args... args) const { + 100 [ + - ]: 14239 : return creator(id)(std::move(args)...); + 101 : : } + 102 : : + 103 : : /** + 104 : : * @brief Checks whether an id is registered. + 105 : : */ + 106 : 2 : [[nodiscard]] bool contains(const ClassId &id) const { + 107 [ + - ]: 2 : return classes.find(id) != classes.end(); + 108 : : } + 109 : : + 110 : : protected: + 111 : : /** @brief Registered creators; accessible to derived factories. */ + 112 : : std::unordered_map<ClassId, CreatorFn> classes; + 113 : : + 114 : : private: + 115 : : template<class Derived> + 116 : 14240 : static BasePtr instantiate(Args... args) { + 117 [ + - ]: 14240 : return std::make_shared<Derived>(std::move(args)...); + 118 : : } + 119 : : }; + 120 : : #endif// TYPEFACTORY_H ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #ifndef VALUE_DESCRIPTIONS_H + 3 : : #define VALUE_DESCRIPTIONS_H + 4 : : + 5 : : #include <cstdint> + 6 : : #include <map> + 7 : : #include <string> + 8 : : #include <variant> + 9 : : + 10 : : using RawSignalValue = std::variant<std::int64_t, std::uint64_t>; + 11 : : + 12 : : /** Canonical keys: negative int64_t, nonnegative uint64_t. */ + 13 : 87 : inline RawSignalValue NormalizeValueKey(const RawSignalValue &value) { + 14 [ + + ]: 87 : if (const std::int64_t *number = std::get_if<std::int64_t>(&value)) { + 15 [ + + ]: 31 : if (*number >= 0) + 16 : 11 : return static_cast<std::uint64_t>(*number); + 17 : : } + 18 : 76 : return value; + 19 : : } + 20 : : + 21 : : using ValueDescriptions = std::map<RawSignalValue, std::string>; + 22 : : + 23 : : /** Returns a borrowed string, or nullptr; never converts integers to double. */ + 24 : 71 : inline const std::string *FindValueDescription(const ValueDescriptions &descriptions, + 25 : : const RawSignalValue &rawValue) { + 26 [ + - ]: 71 : const ValueDescriptions::const_iterator found = descriptions.find(NormalizeValueKey(rawValue)); + 27 [ + + ]: 71 : return found == descriptions.end() ? nullptr : &found->second; + 28 : : } + 29 : : + 30 : : #endif ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
 | |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
Directory  |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| core/ | +
+
|
+ 98.6 % | +1185 | +1168 | +71.6 % | +2152 | +1540 | +100.0 % | +158 | +158 | +|
| qt/ | +
+
|
+ 97.4 % | +115 | +112 | +80.2 % | +212 | +170 | +100.0 % | +11 | +11 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| Directory |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| qt/ | +
+
|
+ 97.4 % | +115 | +112 | +80.2 % | +212 | +170 | +100.0 % | +11 | +11 | +|
| core/ | +
+
|
+ 98.6 % | +1185 | +1168 | +71.6 % | +2152 | +1540 | +100.0 % | +158 | +158 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| Directory |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| qt/ | +
+
|
+ 97.4 % | +115 | +112 | +80.2 % | +212 | +170 | +100.0 % | +11 | +11 | +|
| core/ | +
+
|
+ 98.6 % | +1185 | +1168 | +71.6 % | +2152 | +1540 | +100.0 % | +158 | +158 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| Directory |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| core/ | +
+
|
+ 98.6 % | +1185 | +1168 | +71.6 % | +2152 | +1540 | +100.0 % | +158 | +158 | +|
| qt/ | +
+
|
+ 97.4 % | +115 | +112 | +80.2 % | +212 | +170 | +100.0 % | +11 | +11 | +|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
+Branch data Line data Source code+ + 1 : : // SPDX-License-Identifier: MIT + 2 : : #include "dbc_tree_model.h" + 3 : : #include <QVariantList> + 4 : : #include <QVariantMap> + 5 : : #include <limits> + 6 : : #include <stdexcept> + 7 : : + 8 : : namespace { + 9 : 20 : QVariantList ToVariantList(const ValueDescriptions &values) { + 10 : 20 : QVariantList descriptions; + 11 [ + + ]: 50 : for (const ValueDescriptions::value_type &entry : values) { + 12 : 30 : QVariantMap pair; + 13 [ + + ]: 30 : if (const std::int64_t *number = std::get_if<std::int64_t>(&entry.first)) + 14 [ + - + - ]: 10 : pair.insert("value", QVariant::fromValue(static_cast<qlonglong>(*number))); + 15 : : else + 16 [ + - + - ]: 20 : pair.insert("value", QVariant::fromValue( + 17 [ + - ]: 40 : static_cast<qulonglong>(std::get<std::uint64_t>(entry.first)))); + 18 [ + - + - : 30 : pair.insert("description", QString::fromStdString(entry.second)); + + - ] + 19 [ + - ]: 30 : descriptions.append(pair); + 20 : 30 : } + 21 : 20 : return descriptions; + 22 : 0 : } + 23 : : } // namespace + 24 : : + 25 : 6 : DbcTreeModel::DbcTreeModel(QObject *parent) : QAbstractItemModel(parent) {} + 26 : : + 27 : 12 : void DbcTreeModel::SetTree(std::unique_ptr<TreeNode> root) { + 28 [ + + + + : 12 : if (root && (root->GetType() != NodeType::Root || root->GetParent())) + - + + + ] + 29 [ + - ]: 2 : throw std::invalid_argument("Model requires a detached root node"); + 30 : 10 : beginResetModel(); + 31 : 10 : m_root = std::move(root); + 32 : 10 : endResetModel(); + 33 : 10 : } + 34 : : + 35 : 2110 : const TreeNode *DbcTreeModel::Node(const QModelIndex &index) const { + 36 [ + + + - : 6258 : if (!index.isValid() || index.model() != this || index.column() < 0 || + + - ] + 37 [ + + - + : 6258 : index.column() >= ColumnCount || index.row() < 0) + + + ] + 38 : 39 : return nullptr; + 39 : 2071 : return static_cast<const TreeNode *>(index.internalPointer()); + 40 : : } + 41 : : + 42 : 1254 : QModelIndex DbcTreeModel::index(int row, int column, const QModelIndex &parentIndex) const { + 43 [ + + + + : 3134 : if (row < 0 || column < 0 || column >= ColumnCount || + + + + + + + + ] + 44 [ + + ]: 1880 : (parentIndex.isValid() && parentIndex.column() != 0)) + 45 : 28 : return {}; + 46 [ + + ]: 1226 : const TreeNode *owner = parentIndex.isValid() ? Node(parentIndex) : m_root.get(); + 47 [ + + ]: 1226 : if (!owner) + 48 : 2 : return {}; + 49 : 1224 : const TreeNode *child = owner->GetChild(static_cast<std::size_t>(row)); + 50 [ + + ]: 1224 : return child ? createIndex(row, column, const_cast<TreeNode *>(child)) : QModelIndex(); + 51 : : } + 52 : : + 53 : 783 : QModelIndex DbcTreeModel::parent(const QModelIndex &childIndex) const { + 54 : 783 : const TreeNode *child = Node(childIndex); + 55 [ + + ]: 783 : const TreeNode *owner = child ? child->GetParent() : nullptr; + 56 [ + + + + : 783 : if (!owner || owner == m_root.get()) + + + ] + 57 : 336 : return {}; + 58 : 447 : return createIndex(static_cast<int>(owner->GetRow()), 0, const_cast<TreeNode *>(owner)); + 59 : : } + 60 : : + 61 : 700 : int DbcTreeModel::rowCount(const QModelIndex &parentIndex) const { + 62 [ + + + + : 700 : if (parentIndex.isValid() && parentIndex.column() != 0) + + + ] + 63 : 204 : return 0; + 64 [ + + ]: 496 : const TreeNode *owner = parentIndex.isValid() ? Node(parentIndex) : m_root.get(); + 65 [ + + ]: 496 : if (!owner) + 66 : 53 : return 0; + 67 [ + - ]: 443 : return static_cast<int>(qMin(owner->GetChildCount(), static_cast<std::size_t>(std::numeric_limits<int>::max()))); + 68 : : } + 69 : : + 70 : 395 : int DbcTreeModel::columnCount(const QModelIndex &parentIndex) const { + 71 [ + + + + ]: 395 : return parentIndex.isValid() && !Node(parentIndex) ? 0 : ColumnCount; + 72 : : } + 73 : : + 74 : 240 : QVariant DbcTreeModel::data(const QModelIndex &item, int role) const { + 75 [ + - ]: 240 : const TreeNode *node = Node(item); + 76 [ + + ]: 240 : if (!node) + 77 : 2 : return {}; + 78 [ + - ]: 238 : const FrameInfo *frame = node->GetFrame(); + 79 [ + - ]: 238 : const SignalInfo *signal = node->GetSignal(); + 80 : 238 : QString comment; + 81 [ + + ]: 238 : if (frame != nullptr) + 82 [ + - ]: 126 : comment = QString::fromStdString(frame->comment); + 83 [ + - ]: 112 : else if (signal != nullptr) + 84 [ + - ]: 112 : comment = QString::fromStdString(signal->comment); + 85 [ + + + + ]: 238 : if (role == Qt::ToolTipRole || role == CommentRole) + 86 : 41 : return comment; + 87 [ + + ]: 197 : if (role == NodeTypeRole) + 88 [ + - ]: 2 : return static_cast<int>(node->GetType()); + 89 [ + + + + ]: 195 : if (role == ValueDescriptionsRole && signal) { + 90 [ + - ]: 20 : return ToVariantList(signal->valueDescriptions); + 91 : : } + 92 [ + + ]: 175 : if (frame) { + 93 [ + + ]: 103 : if (role == CanIdRole) + 94 : 10 : return frame->canId; + 95 [ + + ]: 93 : if (role == PayloadLengthRole) + 96 : 10 : return static_cast<int>(frame->dlc); + 97 [ + + ]: 83 : if (role == ExtendedRole) + 98 : 10 : return frame->isExtended; + 99 : : } + 100 [ + + ]: 145 : if (signal) { + 101 [ + + ]: 72 : if (role == StartBitRole) + 102 : 10 : return signal->startBit; + 103 [ + + ]: 62 : if (role == BitLengthRole) + 104 : 10 : return signal->length; + 105 [ + + ]: 52 : if (role == LittleEndianRole) + 106 : 10 : return signal->isLittleEndian; + 107 [ + + ]: 42 : if (role == SignedRole) + 108 : 10 : return signal->isSigned; + 109 [ + + ]: 32 : if (role == UnitRole) + 110 [ + - ]: 10 : return QString::fromStdString(signal->unit); + 111 : : } + 112 [ + + ]: 95 : if (role != Qt::DisplayRole) + 113 : 66 : return {}; + 114 [ + + + + : 29 : switch (item.column()) { + + + + + + + - ] + 115 : 9 : case Name: + 116 [ + - + - ]: 9 : return QString::fromStdString(node->GetName()); + 117 : 4 : case CanId: + 118 [ + + + - : 8 : return frame ? QVariant(QString("0x%1").arg(frame->canId, 0, 16).toUpper()) : QVariant(); + + - + - + + + + + + + + - - - - - + - ] + 119 : 2 : case PayloadLength: + 120 [ + + ]: 2 : return frame ? QVariant(static_cast<int>(frame->dlc)) : QVariant(); + 121 : 2 : case StartBit: + 122 [ + + ]: 2 : return signal ? QVariant(signal->startBit) : QVariant(); + 123 : 2 : case BitLength: + 124 [ + + ]: 2 : return signal ? QVariant(signal->length) : QVariant(); + 125 : 3 : case ByteOrder: + 126 [ + + + + : 3 : return signal ? QVariant(signal->isLittleEndian ? "Intel" : "Motorola") : QVariant(); + + - ] + 127 : 3 : case Signed: + 128 [ + + + + : 3 : return signal ? QVariant(signal->isSigned ? "Signed" : "Unsigned") : QVariant(); + + - ] + 129 : 2 : case Unit: + 130 [ + + + - : 4 : return signal ? QVariant(QString::fromStdString(signal->unit)) : QVariant(); + + + - - ] + 131 : 2 : case Comment: + 132 : 2 : return comment; + 133 : 0 : default: + 134 : 0 : return {}; + 135 : : } + 136 : 238 : } + 137 : : + 138 : 30 : QVariant DbcTreeModel::headerData(int section, Qt::Orientation orientation, int role) const { + 139 : : static const char *const headers[] = {"Name", "CAN ID", "Payload (bytes)", "Start bit", "Length (bits)", "Byte order", "Signedness", "Unit", "Comment"}; + 140 [ + + + + : 30 : if (orientation != Qt::Horizontal || role != Qt::DisplayRole || section < 0 || section >= ColumnCount) + + + + + ] + 141 : 12 : return {}; + 142 [ + - ]: 18 : return QString::fromLatin1(headers[section]); + 143 : : } + 144 : : + 145 : 39 : Qt::ItemFlags DbcTreeModel::flags(const QModelIndex &item) const { + 146 [ + + ]: 39 : return Node(item) ? Qt::ItemIsEnabled | Qt::ItemIsSelectable : Qt::NoItemFlags; + 147 : : } ++ |
+
|
| Generated by: LCOV version 2.0-1 |
| LCOV - code coverage report | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
+
|
+ |||||||||||||||||||||||||||||
|
| + | + | + | + | + | + | + | + | + | + | ||
| File |
+ Line Coverage |
+ Branch Coverage |
+ Function Coverage |
+ ||||||||
| Rate | +Total | +Hit | +Rate | +Total | +Hit | +Rate | +Total | +Hit | +|||
| dbc_tree_model.cpp | +
+
|
+ 97.4 % | +115 | +112 | +80.2 % | +212 | +170 | +100.0 % | +11 | +11 | +|
|
| Generated by: LCOV version 2.0-1 |
