Closes #23

core/dbc_decoder.cpp

@@ -12,6 +12,8 @@
 #include "dbc_decoder.h"
 #include "signal_layout.h"
 #include <cmath>
+#include <stdexcept>
+#include <unordered_set>
 #include <utility>
 
 std::shared_ptr<const DecodeFrame> DbcDecoder::FindFrame(const DecodeDatabase &database,
@@ -22,6 +24,18 @@ std::shared_ptr<const DecodeFrame> DbcDecoder::FindFrame(const DecodeDatabase &d
 
 DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
                                      const RawCanFrame &frame) const {
+    return DecodeImpl(database, frame, nullptr);
+}
+
+DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
+                                     const RawCanFrame &frame,
+                                     const std::vector<SignalKey> &selection) const {
+    return DecodeImpl(database, frame, &selection);
+}
+
+DecodedFrameValue DbcDecoder::DecodeImpl(const DecodeDatabase &database,
+                                         const RawCanFrame &frame,
+                                         const std::vector<SignalKey> *selection) const {
     DecodedFrameValue result;
     result.key = FrameKey(frame.canId, frame.isExtended);
     const std::shared_ptr<const DecodeFrame> definition = FindFrame(database, frame.canId, frame.isExtended);
@@ -29,6 +43,22 @@ DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
     if (definition == nullptr)
         return result;
 
+    std::vector<const DecodeSignal *> selected;
+    if (selection != nullptr) {
+        selected.reserve(selection->size());
+        std::unordered_set<SignalKey, SignalKeyHasher> keys;
+        for (const SignalKey &key: *selection) {
+            if (!(key.frame == result.key))
+                throw std::invalid_argument("Selected signal belongs to another frame: " + key.name);
+            if (!keys.insert(key).second)
+                throw std::invalid_argument("Duplicate selected signal: " + key.name);
+            const std::shared_ptr<const DecodeSignal> signal = database.FindSignal(key);
+            if (!signal)
+                throw std::invalid_argument("Unknown selected signal: " + key.name);
+            selected.push_back(signal.get());
+        }
+    }
+
     result.definition = definition;
     result.valid = true;
     result.status = frame.data.size() < definition->dlc
@@ -36,8 +66,10 @@ DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
                         : FrameDecodeStatus::Valid;
 
     const SelectorState selector = ReadSelector(*definition, frame);
-    result.signals.reserve(definition->signals.size());
-    for (const DecodeSignal &signal: definition->signals) {
+    const std::size_t count = selection != nullptr ? selected.size() : definition->signals.size();
+    result.signals.reserve(count);
+    for (std::size_t index = 0U; index < count; ++index) {
+        const DecodeSignal &signal = selection != nullptr ? *selected[index] : definition->signals[index];
         DecodedSignalValue decoded = DecodeOneSignal(signal, definition->dlc, frame, selector);
         if (!decoded.valid && decoded.status != SignalDecodeStatus::Inactive &&
             result.status == FrameDecodeStatus::Valid)

core/dbc_decoder.h

@@ -104,7 +104,22 @@ public:
     DecodedFrameValue Decode(const DecodeDatabase &database,
                              const RawCanFrame &frame) const;
 
+    /**
+     * @brief Decode selected signals in selection order using stable keys.
+     * An empty selection returns no signals. Multiplex selectors are read internally.
+     * Frame status summarizes selected signals; short payload still takes precedence.
+     * Unknown frames return UnknownFrame before checking the selection.
+     * @throws std::invalid_argument for a foreign frame key, unknown signal, or duplicate key.
+     */
+    DecodedFrameValue Decode(const DecodeDatabase &database,
+                             const RawCanFrame &frame,
+                             const std::vector<SignalKey> &selection) const;
+
 private:
+    DecodedFrameValue DecodeImpl(const DecodeDatabase &database,
+                                 const RawCanFrame &frame,
+                                 const std::vector<SignalKey> *selection) const;
+
     static bool IsValidDefinition(const DecodeSignal &signal, std::uint8_t dlc);
 
     struct SelectorState {