esi_entry.h

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <expected>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <string>
#include <vector>
 
#include "etg/esi.h"
#include "etg/esi_data_type.h"
 
namespace mm::etg {
 
struct EsiEnumOption {
  std::string label;
  int64_t value = 0;
};
 
struct EsiEntrySource {
  enum class Kind : uint8_t { Device, Module };
 
  Kind kind = Kind::Device;
  uint32_t moduleIdent = 0;  
  int32_t slot = -1;         
  uint32_t indexOffset = 0;  
 
  // The module's *name* is deliberately not here: it would be the same string on every one of
  // that module's entries. Resolve `moduleIdent` against the file's module list instead.
};
 
struct EsiEntry {
  uint16_t index = 0;     
  uint8_t subindex = 0;   
  uint16_t rawIndex = 0;  
 
  std::string objectName;   
  std::string entryName;    
  std::string displayName;  
 
  ObjectCode objectCode = ObjectCode::Var;
  uint8_t numberOfEntries = 0;  
 
  std::string dataTypeName;  
  uint16_t dataType = 0;     
 
  ValueKind valueKind = ValueKind::Bytes;
  bool isSigned = false;   
  uint16_t bitSize = 0;    
  uint16_t bitOffset = 0;  
 
  std::optional<std::vector<uint8_t>> defaultData;  
  std::optional<std::vector<uint8_t>> minData;
  std::optional<std::vector<uint8_t>> maxData;
 
  std::optional<uint32_t> unit;  
  std::string unitSymbol;        
 
  Access access{};  
  Category category = Category::Optional;
  PdoMapping pdoMapping = PdoMapping::None;
  SafetyMapping safetyMapping = SafetyMapping::None;
  SdoAccess sdoAccess = SdoAccess::SubIndexAccess;
  bool backup = false;
  bool setting = false;
  std::optional<uint32_t> attribute;  
 
  uint16_t objAccess = 0;
 
  std::vector<Property> properties;
 
  std::string description;  
  std::vector<EsiEnumOption> options;
 
  EsiEntrySource source;
 
  uint32_t key() const { return (static_cast<uint32_t>(index) << 8) | subindex; }
};
 
enum class EsiCollisionPolicy : uint8_t {
  LastWins,   
  FirstWins,  
  Error,      
};
 
struct EsiEntryOptions {
  uint32_t lcId = kDefaultLcId;  
 
  std::vector<uint32_t> moduleIdents;
 
  bool applySlotOffsets = true;  
 
  bool requireDependOnSlot = true;
 
  EsiCollisionPolicy collisionPolicy = EsiCollisionPolicy::LastWins;
 
  bool padShortValues = true;
 
  bool sortByAddress = true;  
 
  std::size_t maxWarnings = 1000;  
};
 
struct EsiEntryTable {
  std::vector<EsiEntry> entries;
  std::vector<std::string> warnings;
};
 
std::expected<EsiEntryTable, std::string> buildDeviceEntries(const EsiFile& file,
                                                             const EsiDevice& device,
                                                             const EsiEntryOptions& options = {});
 
void to_json(nlohmann::json& j, const EsiEnumOption& v);
void to_json(nlohmann::json& j, const EsiEntrySource& v);
void to_json(nlohmann::json& j, const EsiEntry& v);
void to_json(nlohmann::json& j, const EsiEntryTable& v);
 
}  // namespace mm::etg