engine(databroker): Add signals_autocompletion.lua to simulation result

engine/src/simulation.cpp

@@ -1459,13 +1459,35 @@ cloe::Json dump_signals(cloe::DataBroker& db) {
     std::copy(signal->names().begin(), signal->names().end(),
               std::back_inserter(signalreport.names));
 
-    const auto& metadata = signal->metadata();
+    const auto& metadata = signal->metadatas();
   }
 
   auto json = cloe::Json{report};
   return json;
 }
 
+std::vector<std::string> dump_signals_autocompletion(cloe::DataBroker& db) {
+  auto result = std::vector<std::string>{};
+  result.emplace_back("---@meta");
+  result.emplace_back("---@class signals");
+
+  const auto& signals = db.signals();
+  for (const auto& [key, signal] : signals) {
+    const auto* tag = signal->metadata<cloe::LuaAutocompletionTag>();
+    if (tag) {
+      const auto* lua_type = to_ASCIIZ(tag->datatype);
+      const auto& lua_helptext = tag->text;
+      auto line = fmt::format("---@field {} {} {}", key, lua_type, lua_helptext);
+      result.emplace_back(std::move(line));
+    } else {
+      auto line = fmt::format("---@field {}", key);
+      result.emplace_back(std::move(line));
+    }
+  }
+  //
+  return result;
+}
+
 SimulationResult Simulation::run() {
   // Input:
   SimulationContext ctx{lua_.lua_state()};
@@ -1579,6 +1601,7 @@ SimulationResult Simulation::run() {
   r.triggers = ctx.coordinator->history();
   r.report = sol::object(ctx.lua["cloe"]["state"]["report"]);
   r.signals = dump_signals(*ctx.db);
+  r.signals_autocompletion = dump_signals_autocompletion(*ctx.db);
 
   abort_fn_ = nullptr;
   return r;
@@ -1605,6 +1628,7 @@ size_t Simulation::write_output(const SimulationResult& r) const {
   write_file(r.config.engine.output_file_config, r.config);
   write_file(r.config.engine.output_file_triggers, r.triggers);
   write_file(r.config.engine.output_file_signals, r.signals);
+  write_file(r.config.engine.output_file_signals_autocompletion, r.signals_autocompletion);
   logger()->info("Wrote {} output files.", files_written);
 
   return files_written;

engine/src/simulation.hpp

@@ -46,6 +46,8 @@ struct SimulationResult {
   cloe::Json triggers;
   cloe::Json report;
   cloe::Json signals;  // dump of all signals in DataBroker right before the simulation started
+  std::vector<std::string>
+      signals_autocompletion;  // pseudo lua file used for vscode autocompletion
   boost::optional<boost::filesystem::path> output_dir;
 
  public:

engine/src/stack.hpp

@@ -315,6 +315,8 @@ struct EngineConf : public Confable {
   boost::optional<boost::filesystem::path> output_file_result{"result.json"};
   boost::optional<boost::filesystem::path> output_file_triggers{"triggers.json"};
   boost::optional<boost::filesystem::path> output_file_signals{"signals.json"};
+  boost::optional<boost::filesystem::path> output_file_signals_autocompletion{
+      "signals_autocompletion.lua"};
   boost::optional<boost::filesystem::path> output_file_data_stream;
   bool output_clobber_files{true};
 

runtime/include/cloe/data_broker.hpp

@@ -562,11 +562,33 @@ class MetaInformation {
   * Signal-Metainformation for generation of Lua documentation
   */
 struct LuaAutocompletionTag : MetaInformation::Tag<LuaAutocompletionTag> {
+/**
+ * X-Macro style enum-to-string conversion
+*/
+#define LUADATATYPE_LIST \
+  X(Number, 1)           \
+  X(String, 2)
+
   enum class LuaDatatype {
-    Number,
-    String,
+#define X(name, value) name = value,
+    LUADATATYPE_LIST
+#undef X
   };
 
+  friend const char* to_ASCIIZ(LuaDatatype type) {
+    switch (type) {
+#define X(name, value)    \
+  case LuaDatatype::name: \
+    return #name;
+      LUADATATYPE_LIST
+#undef X
+      default:
+        return {};
+    }
+  }
+
+#undef LUADATATYPE_LIST
+
   /**
     * Lua datatype of the signal
     */
@@ -874,9 +896,13 @@ class Signal {
    * \returns bool expressing the presence of the tag, if typename T::tag_type == void
    */
   template <typename T>
-  auto get_metadata() -> decltype(metainformations_.get<T>()) {
+  auto metadata() -> decltype(metainformations_.get<T>()) {
     return metainformations_.get<T>();
   }
+  /**
+   * Get all tags of the signal
+   */
+  const MetaInformation& metadatas() const { return metainformations_; }
 
  private:
   /**

runtime/src/cloe/data_broker_test.cpp

@@ -929,10 +929,10 @@ TEST(metainformations, metainformation_3) {
   signal->add_metadata<principal_tag>(3.1415);
   signal->add_metadata<frivolous_tag>();
   // expected I
-  EXPECT_EQ(*signal->get_metadata<important_tag>(), 1);
-  EXPECT_EQ(*signal->get_metadata<paramount_tag>(), "Hello World");
-  EXPECT_EQ(*signal->get_metadata<principal_tag>(), 3.1415);
-  EXPECT_TRUE(signal->get_metadata<frivolous_tag>());
+  EXPECT_EQ(*signal->metadata<important_tag>(), 1);
+  EXPECT_EQ(*signal->metadata<paramount_tag>(), "Hello World");
+  EXPECT_EQ(*signal->metadata<principal_tag>(), 3.1415);
+  EXPECT_TRUE(signal->metadata<frivolous_tag>());
 }
 
 //         Test Scenario: positive-test