esi_data_type.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <string_view>
 
// <cmath>/<math.h> — pulled in transitively by the STL headers above — defines the obsolete SVID
// matherr macro DOMAIN on macOS/Clang and Windows/MSVC. Left in place it would expand inside the
// kPrimitiveTypes table below and break the build. glibc gates the macro behind a feature test
// that -std=c++2b disables, so only the non-Linux toolchains hit this. See the identical guard in
// libs/comm/object_data_types.h.
#ifdef DOMAIN
#undef DOMAIN
#endif
 
namespace mm::etg {
 
enum class ObjectCode : uint16_t {
  Var = 0x07,     
  Array = 0x08,   
  Record = 0x09,  
};
 
constexpr std::string_view objectCodeName(ObjectCode code) {
  switch (code) {
    case ObjectCode::Var:
      return "VAR";
    case ObjectCode::Array:
      return "ARRAY";
    case ObjectCode::Record:
      return "RECORD";
  }
  return "VAR";
}
 
struct PrimitiveType {
  std::string_view name;  
  uint16_t code = 0;      
  uint16_t bitSize = 0;   
  bool isSigned = false;  
};
 
inline constexpr auto kPrimitiveTypes = std::to_array<PrimitiveType>({
    {"BOOL", 0x0001, 1, false},
    {"BOOLEAN", 0x0001, 1, false},
 
    {"SINT", 0x0002, 8, true},
    {"INT", 0x0003, 16, true},
    {"INT24", 0x0010, 24, true},
    {"DINT", 0x0004, 32, true},
    {"INT40", 0x0012, 40, true},
    {"INT48", 0x0013, 48, true},
    {"INT56", 0x0014, 56, true},
    {"LINT", 0x0015, 64, true},
 
    {"USINT", 0x0005, 8, false},
    {"UINT", 0x0006, 16, false},
    {"UINT24", 0x0016, 24, false},
    {"UDINT", 0x0007, 32, false},
    {"UINT40", 0x0018, 40, false},
    {"UINT48", 0x0019, 48, false},
    {"UINT56", 0x001A, 56, false},
    {"ULINT", 0x001B, 64, false},
 
    {"REAL", 0x0008, 32, false},
    {"LREAL", 0x0011, 64, false},
 
    // Bit-string types. BYTE/WORD/DWORD are distinct CoE codes from the same-width unsigned
    // integers: a device reporting WORD (0x001F) is describing a bitfield, and rendering it as
    // UNSIGNED16 (0x0006) would lose that. v5.6.6.xml uses WORD, so this distinction is live.
    {"BYTE", 0x001E, 8, false},
    {"WORD", 0x001F, 16, false},
    {"DWORD", 0x0020, 32, false},
    {"BITARR8", 0x002D, 8, false},
    {"BITARR16", 0x002E, 16, false},
    {"BITARR32", 0x002F, 32, false},
    {"BIT1", 0x0030, 1, false},
    {"BIT2", 0x0031, 2, false},
    {"BIT3", 0x0032, 3, false},
    {"BIT4", 0x0033, 4, false},
    {"BIT5", 0x0034, 5, false},
    {"BIT6", 0x0035, 6, false},
    {"BIT7", 0x0036, 7, false},
    {"BIT8", 0x0037, 8, false},
    {"BIT9", 0x0038, 9, false},
    {"BIT10", 0x0039, 10, false},
    {"BIT11", 0x003A, 11, false},
    {"BIT12", 0x003B, 12, false},
    {"BIT13", 0x003C, 13, false},
    {"BIT14", 0x003D, 14, false},
    {"BIT15", 0x003E, 15, false},
    {"BIT16", 0x003F, 16, false},
 
    {"GUID", 0x001D, 128, false},
    {"TIME_OF_DAY", 0x000C, 48, false},
    {"TIME_DIFFERENCE", 0x000D, 48, false},
    {"DOMAIN", 0x000F, 0, false},
 
    // Parameterised: width comes from the element count in the name.
    {"STRING", 0x0009, 0, false},          // VISIBLE_STRING, 8 bits per element.
    {"OCTET_STRING", 0x000A, 0, false},    // 8 bits per element.
    {"UNICODE_STRING", 0x000B, 0, false},  // 16 bits per element.
});
 
std::optional<PrimitiveType> resolvePrimitiveType(std::string_view esiName);
 
std::string_view arrayElementTypeName(std::string_view esiName);
 
bool isStringTypeName(std::string_view esiName);
 
enum class ValueKind : uint8_t {
  Bool,    
  Int8,    
  Int16,   
  Int32,   
  Int64,   
  Uint8,   
  Uint16,  
  Uint32,  
  Uint64,  
  Real32,  
  Real64,  
  String,  
  Bytes,   
};
 
constexpr std::string_view cxxTypeName(ValueKind kind) {
  switch (kind) {
    case ValueKind::Bool:
    case ValueKind::Uint8:
      return "uint8_t";
    case ValueKind::Int8:
      return "int8_t";
    case ValueKind::Int16:
      return "int16_t";
    case ValueKind::Int32:
      return "int32_t";
    case ValueKind::Int64:
      return "int64_t";
    case ValueKind::Uint16:
      return "uint16_t";
    case ValueKind::Uint32:
      return "uint32_t";
    case ValueKind::Uint64:
      return "uint64_t";
    case ValueKind::Real32:
      return "float";
    case ValueKind::Real64:
      return "double";
    case ValueKind::String:
      return "std::string";
    case ValueKind::Bytes:
      return "std::vector<uint8_t>";
  }
  return "std::vector<uint8_t>";
}
 
ValueKind resolveValueKind(uint16_t dataType, uint16_t bitSize);
 
void to_json(nlohmann::json& j, const PrimitiveType& type);
 
}  // namespace mm::etg