Added a GeneratorContext class to manage un/tracked variables.

agarny · agarny · commit eb8671c8a687 · 2025-11-21T21:57:18.000+13:00
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -49,6 +49,7 @@ set(SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/entity.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/enums.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/generator.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/generatorcontext.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofile.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofiletools.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/importedentity.cpp
@@ -90,6 +91,7 @@ set(GIT_API_HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/entity.h
   ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/enums.h
   ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/generator.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/generatorcontext.h
   ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/generatorprofile.h
   ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importedentity.h
   ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importer.h
@@ -134,6 +136,7 @@ set(GIT_HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/debug.h
   ${CMAKE_CURRENT_SOURCE_DIR}/entity_p.h
   ${CMAKE_CURRENT_SOURCE_DIR}/generator_p.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/generatorcontext_p.h
   ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofile_p.h
   ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofilesha1values.h
   ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofiletools.h
diff --git a/src/api/libcellml/generator.h b/src/api/libcellml/generator.h
@@ -16,6 +16,7 @@ limitations under the License.
 
 #pragma once
 
+#include "libcellml/generatorcontext.h"
 #include "libcellml/logger.h"
 
 namespace libcellml {
@@ -46,6 +47,24 @@ class LIBCELLML_EXPORT Generator: public Logger
      */
     static GeneratorPtr create() noexcept;
 
+    /**
+     * @brief Get the @ref GeneratorContext.
+     *
+     * Get the @ref GeneratorContext used by this @ref Generator.
+     *
+     * @return The @ref GeneratorContext used.
+     */
+    GeneratorContextPtr context();
+
+    /**
+     * @brief Set the @ref GeneratorContext.
+     *
+     * Set the @ref GeneratorContext to be used by this @ref Generator.
+     *
+     * @param context The @ref GeneratorContext to set.
+     */
+    void setContext(const GeneratorContextPtr &context);
+
     /**
      * @brief Get the @ref GeneratorProfile.
      *
diff --git a/src/api/libcellml/generatorcontext.h b/src/api/libcellml/generatorcontext.h
@@ -0,0 +1,58 @@
+/*
+Copyright libCellML Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#pragma once
+
+#include "libcellml/logger.h"
+
+namespace libcellml {
+
+/**
+ * @brief The GeneratorContext class.
+ *
+ * The GeneratorContext class is for representing a CellML GeneratorContext.
+ */
+class LIBCELLML_EXPORT GeneratorContext: public Logger
+{
+public:
+    ~GeneratorContext(); /**< Destructor, @private. */
+    GeneratorContext(const GeneratorContext &rhs) = delete; /**< Copy constructor, @private. */
+    GeneratorContext(GeneratorContext &&rhs) noexcept = delete; /**< Move constructor, @private. */
+    GeneratorContext &operator=(GeneratorContext rhs) = delete; /**< Assignment operator, @private. */
+
+    /**
+     * @brief Create a @ref GeneratorContext object.
+     *
+     * Factory method to create a @ref GeneratorContext. Create a GeneratorContext with::
+     *
+     * @code
+     *   auto GeneratorContext = libcellml::GeneratorContext::create();
+     * @endcode
+     *
+     * @return A smart pointer to a @ref GeneratorContext object.
+     */
+    static GeneratorContextPtr create() noexcept;
+
+private:
+    GeneratorContext(); /**< Constructor, @private. */
+
+    struct GeneratorContextImpl;
+
+    GeneratorContextImpl *pFunc(); /**< Getter for private implementation pointer, @private. */
+    const GeneratorContextImpl *pFunc() const; /**< Const getter for private implementation pointer, @private. */
+};
+
+} // namespace libcellml
diff --git a/src/api/libcellml/module/libcellml b/src/api/libcellml/module/libcellml
@@ -34,6 +34,7 @@ limitations under the License.
 #include "libcellml/component.h"
 #include "libcellml/enums.h"
 #include "libcellml/generator.h"
+#include "libcellml/generatorcontext.h"
 #include "libcellml/generatorprofile.h"
 #include "libcellml/importer.h"
 #include "libcellml/importsource.h"
diff --git a/src/api/libcellml/types.h b/src/api/libcellml/types.h
@@ -46,6 +46,8 @@ using AnyCellmlElementPtr = std::shared_ptr<AnyCellmlElement>; /**< Type definit
 
 class Generator; /**< Forward declaration of Generator class. */
 using GeneratorPtr = std::shared_ptr<Generator>; /**< Type definition for shared generator pointer. */
+class GeneratorContext; /**< Forward declaration of GeneratorContext class. */
+using GeneratorContextPtr = std::shared_ptr<GeneratorContext>; /**< Type definition for shared generator context pointer. */
 class GeneratorProfile; /**< Forward declaration of GeneratorProfile class. */
 using GeneratorProfilePtr = std::shared_ptr<GeneratorProfile>; /**< Type definition for shared generator variable pointer. */
 class Importer; /**< Forward declaration of Importer class. */
diff --git a/src/bindings/interface/generator.i b/src/bindings/interface/generator.i
@@ -6,12 +6,19 @@
 
 %import "analysermodel.i"
 %import "createconstructor.i"
+%import "generatorcontext.i"
 %import "generatorprofile.i"
 %import "logger.i"
 
 %feature("docstring") libcellml::Generator
 "Creates a :class:`Generator` object.";
 
+%feature("docstring") libcellml::Generator::context
+"Returns the context used for code generation.";
+
+%feature("docstring") libcellml::Generator::setContext
+"Sets the context to use for code generation.";
+
 %feature("docstring") libcellml::Generator::profile
 "Returns the profile used for code generation.";
 
diff --git a/src/bindings/interface/generatorcontext.i b/src/bindings/interface/generatorcontext.i
@@ -0,0 +1,21 @@
+%module(package="libcellml") generatorcontext
+
+#define LIBCELLML_EXPORT
+
+%import "createconstructor.i"
+%import "logger.i"
+
+%feature("docstring") libcellml::GeneratorContext
+"Creates a :class:`GeneratorContext` object.";
+
+%{
+#include "libcellml/generatorcontext.h"
+%}
+
+%pythoncode %{
+# libCellML generated wrapper code starts here.
+%}
+
+%create_constructor(GeneratorContext)
+
+%include "libcellml/generatorcontext.h"
diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i
@@ -25,6 +25,7 @@ Provides support for shared pointers declared in types.h.
 %shared_ptr(libcellml::ComponentEntity)
 %shared_ptr(libcellml::Entity)
 %shared_ptr(libcellml::Generator)
+%shared_ptr(libcellml::GeneratorContext)
 %shared_ptr(libcellml::GeneratorProfile)
 %shared_ptr(libcellml::Importer)
 %shared_ptr(libcellml::ImportSource)
diff --git a/src/bindings/javascript/CMakeLists.txt b/src/bindings/javascript/CMakeLists.txt
@@ -12,6 +12,7 @@ set(SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/entity.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/enums.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/generator.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/generatorcontext.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofile.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/importedentity.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/importer.cpp
diff --git a/src/bindings/javascript/generator.cpp b/src/bindings/javascript/generator.cpp
@@ -18,6 +18,7 @@ limitations under the License.
 
 #include "libcellml/analyserequationast.h"
 #include "libcellml/generator.h"
+#include "libcellml/generatorcontext.h"
 #include "libcellml/generatorprofile.h"
 
 using namespace emscripten;
@@ -26,6 +27,8 @@ EMSCRIPTEN_BINDINGS(libcellml_generator)
 {
     class_<libcellml::Generator, base<libcellml::Logger>>("Generator")
         .smart_ptr_constructor("Generator", &libcellml::Generator::create)
+        .function("context", &libcellml::Generator::context)
+        .function("setContext", &libcellml::Generator::setContext)
         .function("profile", &libcellml::Generator::profile)
         .function("setProfile", &libcellml::Generator::setProfile)
         .function("isTrackedVariable", &libcellml::Generator::isTrackedVariable)
diff --git a/src/bindings/javascript/generatorcontext.cpp b/src/bindings/javascript/generatorcontext.cpp
@@ -0,0 +1,28 @@
+/*
+Copyright libCellML Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <emscripten/bind.h>
+
+#include "libcellml/generatorcontext.h"
+
+using namespace emscripten;
+
+EMSCRIPTEN_BINDINGS(libcellml_generatorcontext)
+{
+    class_<libcellml::GeneratorContext, base<libcellml::Logger>>("GeneratorContext")
+        .smart_ptr_constructor("GeneratorContext", &libcellml::GeneratorContext::create)
+    ;
+}
diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt
@@ -27,6 +27,7 @@ set(SWIG_INTERFACE_SRCS
     ../interface/entity.i
     ../interface/enums.i
     ../interface/generator.i
+    ../interface/generatorcontext.i
     ../interface/generatorprofile.i
     ../interface/importer.i
     ../interface/importsource.i
diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py
@@ -19,6 +19,7 @@
 from libcellml.component import Component
 from libcellml.enums import CellmlElementType, cellmlElementTypeAsString
 from libcellml.generator import Generator
+from libcellml.generatorcontext import GeneratorContext
 from libcellml.generatorprofile import GeneratorProfile
 from libcellml.importer import Importer
 from libcellml.importsource import ImportSource
diff --git a/src/generator.cpp b/src/generator.cpp
@@ -2565,6 +2565,16 @@ GeneratorPtr Generator::create() noexcept
     return std::shared_ptr<Generator> {new Generator {}};
 }
 
+GeneratorContextPtr Generator::context()
+{
+    return pFunc()->mContext;
+}
+
+void Generator::setContext(const GeneratorContextPtr &context)
+{
+    pFunc()->mContext = context;
+}
+
 GeneratorProfilePtr Generator::profile()
 {
     return pFunc()->mProfile;
diff --git a/src/generator_p.h b/src/generator_p.h
@@ -37,6 +37,7 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl
 {
     std::string mCode;
 
+    GeneratorContextPtr mContext;
     GeneratorProfilePtr mProfile = GeneratorProfile::create();
 
     std::map<AnalyserModelPtr, std::map<AnalyserVariablePtr, bool>> mTrackedVariables;
diff --git a/src/generatorcontext.cpp b/src/generatorcontext.cpp
@@ -0,0 +1,50 @@
+/*
+Copyright libCellML Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "libcellml/generatorcontext.h"
+
+#include "generatorcontext_p.h"
+
+namespace libcellml {
+
+GeneratorContext::GeneratorContextImpl *GeneratorContext::pFunc()
+{
+    return reinterpret_cast<GeneratorContext::GeneratorContextImpl *>(Logger::pFunc());
+}
+
+/*TODO
+const GeneratorContext::GeneratorContextImpl *GeneratorContext::pFunc() const
+{
+    return reinterpret_cast<GeneratorContext::GeneratorContextImpl const *>(Logger::pFunc());
+}
+*/
+
+GeneratorContext::GeneratorContext()
+    : Logger(new GeneratorContextImpl())
+{
+}
+
+GeneratorContext::~GeneratorContext()
+{
+    delete pFunc();
+}
+
+GeneratorContextPtr GeneratorContext::create() noexcept
+{
+    return std::shared_ptr<GeneratorContext> {new GeneratorContext {}};
+}
+
+} // namespace libcellml
diff --git a/src/generatorcontext_p.h b/src/generatorcontext_p.h
@@ -0,0 +1,34 @@
+/*
+Copyright libCellML Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#pragma once
+
+#include "libcellml/generatorcontext.h"
+
+#include "logger_p.h"
+
+namespace libcellml {
+
+/**
+ * @brief The GeneratorContext::GeneratorContextImpl struct.
+ *
+ * The private implementation for the GeneratorContext class.
+ */
+struct GeneratorContext::GeneratorContextImpl: public Logger::LoggerImpl
+{
+};
+
+} // namespace libcellml
diff --git a/tests/bindings/javascript/CMakeLists.txt b/tests/bindings/javascript/CMakeLists.txt
@@ -25,6 +25,7 @@ set(TEST_SRCS
   entity.test.js
   enums.test.js
   generator.test.js
+  generatorcontext.test.js
   generatorprofile.test.js
   importsource.test.js
   model.test.js
diff --git a/tests/bindings/javascript/generatorcontext.test.js b/tests/bindings/javascript/generatorcontext.test.js
diff --git a/tests/bindings/python/CMakeLists.txt b/tests/bindings/python/CMakeLists.txt
diff --git a/tests/bindings/python/test_generator.py b/tests/bindings/python/test_generator.py
diff --git a/tests/bindings/python/test_generator_context.py b/tests/bindings/python/test_generator_context.py
diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp
diff --git a/tests/generator/generatorcontext.cpp b/tests/generator/generatorcontext.cpp
diff --git a/tests/generator/tests.cmake b/tests/generator/tests.cmake
