decode_database.h

Go to the documentation of this file.

 
#ifndef DECODE_DATABASE_H
#define DECODE_DATABASE_H
 
#include "attributes.h"
#include "definition_key.h"
#include "multiplexing.h"
#include "value_descriptions.h"
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
enum class ByteOrder {
    Intel,
    Motorola
};
 
enum class ValueType {
    Unsigned,
    Signed
};
 
struct DecodeSignal {
    Multiplexing multiplexing;                 
    std::string name;                          
    std::uint32_t startBit = 0U;               
    std::uint32_t length = 0U;                 
    ByteOrder byteOrder = ByteOrder::Intel;    
    ValueType valueType = ValueType::Unsigned; 
    double factor = 1.0;                       
    double offset = 0.0;                       
    double minimum = 0.0;                      
    double maximum = 0.0;                      
    std::string unit;                          
    std::vector<std::string> receivers;        
    ValueDescriptions valueDescriptions;       
    std::string comment;                       
    AttributeMap attributes; 
    DecodeSignal() = default;
};
 
struct DecodeFrame {
    std::string name;                  
    std::uint32_t canId = 0U;          
    bool isExtended = false;           
    std::uint8_t dlc = 0U;             
    std::uint32_t pgn = 0U;            
    bool hasPgn = false;               
    std::string transmitter;           
    std::string comment;               
    std::vector<DecodeSignal> signals; 
    AttributeMap attributes;                  
    std::optional<std::string> frameFormat;   
    std::optional<std::uint32_t> cycleTimeMs; 
    DecodeFrame() = default;
 
    FrameKey GetKey() const {
        return FrameKey(canId, isExtended);
    }
};
 
struct PgnLookupResult {
    std::shared_ptr<const DecodeFrame> definition; 
    bool ambiguous = false;                        
};
 
class DecodeDatabase {
public:
    DecodeDatabase() = default;
    explicit DecodeDatabase(const std::vector<DecodeFrame> &frames);
 
    const std::vector<DecodeFrame> &GetFrames() const;
    std::shared_ptr<const DecodeFrame> FindFrame(const FrameKey &key) const;
    PgnLookupResult FindFrameByPgn(std::uint32_t pgn) const;
    std::shared_ptr<const DecodeSignal> FindSignal(const SignalKey &key) const;
 
private:
    struct Storage {
        std::vector<DecodeFrame> frames;
        std::unordered_map<FrameKey, std::size_t, FrameKeyHasher> frameIndexByKey;
 
        std::unordered_map<std::uint32_t, std::vector<std::size_t>> frameIndicesByPgn;
 
        explicit Storage(const std::vector<DecodeFrame> &definitions);
    };
 
    std::shared_ptr<const Storage> storage;
};
 
#endif /* DECODE_DATABASE_H */