decode_database.h

Go to the documentation of this file.

 
#ifndef DECODE_DATABASE_H
#define DECODE_DATABASE_H
 
#include <string>
#include <vector>
#include <unordered_map>
#include <cstdint>
 
enum class ByteOrder {
  Intel,
  Motorola
};
 
enum class ValueType {
  Unsigned,
  Signed
};
 
struct DecodeSignal {
  std::string name;                   
  std::uint32_t startBit;             
  std::uint32_t length;               
  ByteOrder byteOrder;                
  ValueType valueType;                
  double factor;                      
  double offset;                      
  double minimum;                     
  double maximum;                     
  std::string unit;                   
  std::vector<std::string> receivers; 
  std::string comment;                
  DecodeSignal()
    : name()
    , startBit (0U)
    , length (0U)
    , byteOrder (ByteOrder::Intel)
    , valueType (ValueType::Unsigned)
    , factor (1.0)
    , offset (0.0)
    , minimum (0.0)
    , maximum (0.0)
    , unit()
    , receivers()
    , comment() {
  }
};
 
struct DecodeFrame {
  std::string name;                
  std::uint32_t canId;             
  bool isExtended;                 
  std::uint8_t dlc;                
  std::uint32_t pgn;               
  bool hasPgn;                     
  std::string transmitter;         
  std::string comment;             
  std::vector<DecodeSignal> signals; 
  DecodeFrame()
    : name()
    , canId (0U)
    , isExtended (false)
    , dlc (0U)
    , pgn (0U)
    , hasPgn (false)
    , transmitter()
    , comment()
    , signals() {
  }
};
 
struct FrameKey {
  std::uint32_t canId;
  bool isExtended;
 
  FrameKey()
    : canId (0U)
    , isExtended (false) {
  }
 
  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 */