[dev] Add execution context to example application

Author: d-leroy

.gitignore

@@ -1,3 +1,4 @@
 .vscode
+.venv
 **/__pycache__
 **/build

examples/simple-embedding/src/SimpleEmbedding.cc

@@ -5,18 +5,45 @@ PYBIND11_EMBEDDED_MODULE(example_interface, m) { }
 
 namespace fs = std::filesystem;
 
+struct SimpleExecutionContext : MoniLog::MoniLogExecutionContext
+{
+	const pybind11::object get_foo() const { if (foo != nullptr) return pybind11::cast(*foo); else return pybind11::cast<pybind11::none>(Py_None); }
+	
+	double *foo = nullptr;
+	
+	using MoniLog::MoniLogExecutionContext::MoniLogExecutionContext;
+};
+
 int main()
 {
     // Retrieve the path where the Python scripts to use are located (can provide multiple locations).
     std::string path = fs::current_path();
     std::vector<std::string> python_path = { path + "/src/" };
+    
     // Provide the Python scripts to include.
     std::vector<std::string> python_scripts = {"example_moniloggers"};
+
     // Name of the interface module (here, an embedded module declared above) exposing the execution context of the application.
     std::string interface_module = "example_interface";
+
     // Initialization function for the interface module.
     std::function<void (pybind11::module_, pybind11::object)> interface_module_initializer =
-            [](pybind11::module_ iterativeheatequation_module, pybind11::object context_class) { };
+            [](pybind11::module_ interface_module, pybind11::object context_class) {
+        pybind11::class_<SimpleExecutionContext, std::shared_ptr<SimpleExecutionContext>>(interface_module, "SimpleExecutionContext", context_class)
+            .def_property_readonly("foo", &SimpleExecutionContext::get_foo)
+            .def("__str__", [](SimpleExecutionContext &self)
+                {
+                    std::ostringstream oss;
+                    oss << self.name;
+                    return oss.str();
+                })
+            .def("__repr__", [](SimpleExecutionContext &self)
+                {
+                    std::ostringstream oss;
+                    oss << self.name;
+                    return oss.str();
+                });
+    };
 
     // Define base execution events emitted by the application, to which moniloggers can register.
     MoniLog::register_base_events({
@@ -28,17 +55,27 @@ int main()
     MoniLog::register_composite_event("SomeCompositeEvent", {"SomeEvent", "SomeOtherEvent"});
 
     // Instantiating the execution context accessible from Python.
-    std::shared_ptr<MoniLog::MoniLogExecutionContext> ctx(new MoniLog::MoniLogExecutionContext());
+    std::shared_ptr<SimpleExecutionContext> ctx(new SimpleExecutionContext("SimpleExecutionContext"));
 
     // Bootstrapping monilog, consisting mainly of starting the Python interpreter, initializing
     // the monilog module, and evaluating the provided scripts.
     MoniLog::bootstrap_monilog(python_path, python_scripts, interface_module, interface_module_initializer);
 
+    double foo(0.0);
+    ctx->foo = &foo;
+
     // Emitting some base events, triggering the registered moniloggers.
     MoniLog::trigger(0, ctx);
+
+    foo = 17.0;
+
     MoniLog::trigger(1, ctx);
 
+    foo = 42.0;
+
     // Emitting a composite event (can also emit base event by name).
     MoniLog::trigger("SomeCompositeEvent", ctx);
 
+    foo = 17.0;
+
 }

examples/simple-embedding/src/example_moniloggers.py

@@ -3,11 +3,14 @@
 @register("SomeEvent")
 def monilogger1(ctx):
     print("monilogger 1 triggered!")
+    print("foo = " + str(ctx.foo))
 
 @register("SomeOtherEvent")
 def monilogger2(ctx):
     print("monilogger 2 triggered!")
+    print("foo = " + str(ctx.foo))
 
 @register("SomeCompositeEvent")
 def monilogger3(ctx):
-    print("monilogger 3 triggered!")
+    print("monilogger 3 triggered!")
+    print("foo = " + str(ctx.foo))