Closes #14

core/dbc_decoder.cpp

@@ -10,28 +10,19 @@
  */
 
 #include "dbc_decoder.h"
+#include <utility>
 
-const DecodeFrame *DbcDecoder::FindFrame(const DecodeDatabase &database,
-                                         std::uint32_t canId,
-                                         bool isExtended) const {
-    const FrameKey key(canId, isExtended);
-    const std::unordered_map<FrameKey, std::size_t, FrameKeyHasher>::const_iterator it =
-            database.frameIndexByKey.find(key);
-
-    if (it == database.frameIndexByKey.end())
-        return nullptr;
-
-    const std::size_t index = it->second;
-    if (index >= database.frames.size())
-        return nullptr;
-
-    return &database.frames[index];
+std::shared_ptr<const DecodeFrame> DbcDecoder::FindFrame(const DecodeDatabase &database,
+                                                         std::uint32_t canId,
+                                                         bool isExtended) const {
+    return database.FindFrame(FrameKey(canId, isExtended));
 }
 
 DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
                                      const RawCanFrame &frame) const {
     DecodedFrameValue result;
-    const DecodeFrame *definition = FindFrame(database, frame.canId, frame.isExtended);
+    result.key = FrameKey(frame.canId, frame.isExtended);
+    const std::shared_ptr<const DecodeFrame> definition = FindFrame(database, frame.canId, frame.isExtended);
 
     if (definition == nullptr)
         return result;
@@ -40,17 +31,22 @@ DecodedFrameValue DbcDecoder::Decode(const DecodeDatabase &database,
     result.valid = true;
 
     const SelectorState selector = ReadSelector(*definition, frame);
-    for (const DecodeSignal &signal : definition->signals)
-        result.signals.push_back(DecodeOneSignal(signal, frame, selector));
+    result.signals.reserve(definition->signals.size());
+    for (const DecodeSignal &signal: definition->signals) {
+        DecodedSignalValue decoded = DecodeOneSignal(signal, frame, selector);
+        decoded.definition = std::shared_ptr<const DecodeSignal>(definition, &signal);
+        decoded.key = SignalKey(result.key, signal.name);
+        result.signals.push_back(std::move(decoded));
+    }
 
     return result;
 }
 
 DbcDecoder::SelectorState DbcDecoder::ReadSelector(const DecodeFrame &definition,
-                                                  const RawCanFrame &frame) {
+                                                   const RawCanFrame &frame) {
     SelectorState selector;
     std::size_t count = 0U;
-    for (const DecodeSignal &signal : definition.signals) {
+    for (const DecodeSignal &signal: definition.signals) {
         if (signal.multiplexing.role == MultiplexRole::Selector) {
             selector.definition = &signal;
             ++count;
@@ -67,13 +63,11 @@ DbcDecoder::SelectorState DbcDecoder::ReadSelector(const DecodeFrame &definition
 }
 
 DecodedSignalValue DbcDecoder::DecodeOneSignal(const DecodeSignal &signal,
-                                              const RawCanFrame &frame,
-                                              const SelectorState &selector) {
+                                               const RawCanFrame &frame,
+                                               const SelectorState &selector) {
     DecodedSignalValue decoded;
     std::uint64_t unsignedValue = 0U;
 
-    decoded.definition = &signal;
-
     if (signal.length == 0U || signal.length > 64U ||
         (signal.multiplexing.role != MultiplexRole::Unconditional && !selector.valid)) {
         return decoded;