decode_database.h

Go to the documentation of this file.

 
#ifndef DECODE_DATABASE_H
#define DECODE_DATABASE_H
 
#include "value_descriptions.h"
#include "multiplexing.h"
#include <cstdint>
#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;                         
    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;           
    DecodeFrame() = default;
};
 
struct FrameKey {
    std::uint32_t canId = 0U;
    bool isExtended = false;
 
    FrameKey() = default;
 
    FrameKey(std::uint32_t id, bool extended)
        : canId(id), isExtended(extended) {
    }
 
    bool operator==(const FrameKey &other) const {
        return (canId == other.canId) && (isExtended == other.isExtended);
    }
};
 
struct FrameKeyHasher {
    std::size_t operator()(const FrameKey &key) const {
        const std::size_t a = static_cast<std::size_t>(key.canId);
        const std::size_t b = key.isExtended ? 1U : 0U;
        return (a * 1315423911U) ^ b;
    }
};
 
struct DecodeDatabase {
    std::vector<DecodeFrame> frames;
    std::unordered_map<FrameKey, std::size_t, FrameKeyHasher> frameIndexByKey;
};
 
#endif /* DECODE_DATABASE_H */