Work on subtraction test

Author: LukasMolzberger

CMakeLists.txt

@@ -21,7 +21,6 @@ set(SOURCES
         src/fields/obj.cpp
         src/fields/type.cpp
         src/fields/type_registry.cpp
-        src/fields/type_registry_python.cpp
         src/fields/flattened_type.cpp
         src/fields/flattened_type_relation.cpp
         src/fields/relation.cpp
@@ -34,6 +33,7 @@ set(SOURCES
         src/fields/step.cpp
         src/fields/test_type.cpp
         src/fields/test_object.cpp
+        src/fields/python_bindings.cpp
         src/network/model.cpp
 )
 

README.md

@@ -28,6 +28,12 @@ cmake --build . --target install
 python tests/subtraction-test.py
 ```
 
+Additionally, ensure that the `parameterized` package is installed for running parameterized tests. You can install it using:
+
+```bash
+pip install parameterized
+```
+
 **Steps explained:**
 
 1. Activate the Python virtual environment (here, `.venv`) so that Python dependencies and the installation target are set up correctly.

tests/subtraction-test.py renamed to python-tests/subtraction-test.py

@@ -1,6 +1,7 @@
 import unittest
 import sys
 import os
+from parameterized import parameterized
 
 # Add the project root to Python's module search path
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
@@ -9,7 +10,12 @@
 
 class MyTestCase(unittest.TestCase):
 
-    def testSubtraction(self):
+    @parameterized.expand([
+        (0, "linking_pos_0"),
+        (1, "linking_pos_1"),
+        (2, "linking_pos_2")
+    ])
+    def testSubtraction(self, linking_pos, test_name):
         print("Module 'aika' was loaded from:", aika.__file__)
 
         TEST_RELATION_FROM = aika.RelationOne(1, "TEST_FROM")
@@ -45,6 +51,23 @@ def testSubtraction(self):
         oa = typeA.instantiate()
         ob = typeB.instantiate()
 
+        if linking_pos == 0:
+            aika.TestObj.linkObjects(oa, ob)
+            ob.initFields()
+
+        oa.setFieldValue(a, 50.0)
+
+        if linking_pos == 1:
+            aika.TestObj.linkObjects(oa, ob)
+            ob.initFields()
+
+        oa.setFieldValue(b, 20.0)
+
+        if linking_pos == 2:
+            aika.TestObj.linkObjects(oa, ob)
+            ob.initFields()
+
+        self.assertEqual(30.0, ob.getFieldOutput(c).getValue())
 
 if __name__ == '__main__':
     unittest.main()

tests/test_basic.py renamed to python-tests/test-type-registry.py

@@ -43,6 +43,17 @@ FlattenedType::FlattenedType(Direction* dir, Type* type, const std::map<FieldDef
     }
 }
 
+/**
+ * @brief Creates a flattened type for input direction
+ * 
+ * This function creates a flattened type representation for the input direction.
+ * It takes a type and a set of field definitions, and maps the field definitions
+ * to their corresponding indices in the flattened type.
+ * 
+ * @param type The type to flatten
+ * @param fieldDefs The set of field definitions to include in the flattened type
+ * @return A new FlattenedType object representing the input flattened type
+ */
 FlattenedType* FlattenedType::createInputFlattenedType(Type* type, const std::set<FieldDefinition*>& fieldDefs) {
     std::map<FieldDefinition*, int> fieldMappings;
 
@@ -60,6 +71,18 @@ FlattenedType* FlattenedType::createInputFlattenedType(Type* type, const std::se
     return new FlattenedType(Direction::INPUT, type, fieldMappings, requiredFields.size());
 }
 
+/**
+ * @brief Creates a flattened type for output direction
+ * 
+ * This function creates a flattened type representation for the output direction.
+ * It takes a type and a set of field definitions, and maps the field definitions
+ * to their corresponding indices in the flattened type.    
+ * 
+ * @param type The type to flatten
+ * @param fieldDefs The set of field definitions to include in the flattened type
+ * @param inputSide The flattened type of the input side
+ * @return A new FlattenedType object representing the output flattened type
+ */
 FlattenedType* FlattenedType::createOutputFlattenedType(Type* type, const std::set<FieldDefinition*>& fieldDefs, FlattenedType* inputSide) {
     std::map<FieldDefinition*, int> fieldMappings;
     for (const auto& fd : fieldDefs) {
@@ -71,6 +94,16 @@ FlattenedType* FlattenedType::createOutputFlattenedType(Type* type, const std::s
     return new FlattenedType(Direction::OUTPUT, type, fieldMappings, inputSide->numberOfFields);
 }
 
+/**
+ * @brief Checks if all elements in a vector are null
+ * 
+ * This function checks if all elements in a vector are null.
+ * It iterates through the vector and returns true if all elements are null,    
+ * otherwise it returns false.
+ * 
+ * @param vec The vector to check
+ * @return true if all elements are null, otherwise false
+ */
 template <typename T>
 bool isAllNull(const std::vector<T>& vec) {
     for (const auto& element : vec) {
@@ -81,6 +114,13 @@ bool isAllNull(const std::vector<T>& vec) {
     return true; // If no non-null element is found, return true
 }
 
+/**
+ * @brief Flattens the type hierarchy
+ * 
+ * This function flattens the type hierarchy by creating a mapping of relations
+ * to their corresponding flattened type relations. It iterates through all 
+ * relations and types to build the mapping.
+ */
 void FlattenedType::flatten() {
     mapping = new FlattenedTypeRelation**[type->getRelations().size()];
 
@@ -101,6 +141,17 @@ void FlattenedType::flatten() {
     }
 }
 
+/**
+ * @brief Flattens the type hierarchy per type
+ * 
+ * This function flattens the type hierarchy per type by creating a mapping of
+ * field links for a given relation and related type. It iterates through all
+ * field definitions and their corresponding field link definitions to build the mapping.
+ * 
+ * @param relation The relation to flatten
+ * @param relatedType The related type to flatten
+ * @return A new FlattenedTypeRelation object representing the flattened type relation
+ */
 FlattenedTypeRelation* FlattenedType::flattenPerType(Relation* relation, Type* relatedType) {
     std::vector<FieldLinkDefinition*> fieldLinks;
 
@@ -128,6 +179,15 @@ FlattenedTypeRelation* FlattenedType::flattenPerType(Relation* relation, Type* r
                               new FlattenedTypeRelation(this, fieldLinks);
 }
 
+/**
+ * @brief Follows links in the flattened type
+ * 
+ * This function follows links in the flattened type by iterating through all
+ * relations and their corresponding flattened type relations. It iterates through
+ * all relations and their corresponding flattened type relations to follow links.
+ * 
+ * @param field The field to follow links from
+ */
 void FlattenedType::followLinks(Field* field) {
     for (int relationId = 0; relationId < type->getRelations().size(); relationId++) {
         auto& ftr = mapping[relationId];
@@ -146,28 +206,76 @@ void FlattenedType::followLinks(Field* field) {
     }
 }
 
+/**
+ * @brief Follows links in the flattened type relation
+ * 
+ * This function follows links in the flattened type relation by iterating through
+ * all field links and their corresponding field link definitions.  
+ * 
+ * @param ftr The flattened type relation to follow links from
+ * @param relatedObj The related object to follow links from
+ * @param field The field to follow links from
+ */
 void FlattenedType::followLinks(FlattenedTypeRelation* ftr, Obj* relatedObj, Field* field) {
     if (ftr != nullptr) {
         ftr->followLinks(direction, relatedObj, field);
     }
 }
 
+/**
+ * @brief Gets the field index
+ * 
+ * This function gets the field index by looking up the field definition in the
+ * flattened type.  
+ * 
+ * @param fd The field definition to get the index of
+ * @return The index of the field definition
+ */
 int FlattenedType::getFieldIndex(FieldDefinition* fd) {
     return fields[fd->getId()];
 }
 
+/**
+ * @brief Gets the number of fields
+ * 
+ * This function gets the number of fields in the flattened type.
+ * 
+ * @return The number of fields in the flattened type
+ */ 
 int FlattenedType::getNumberOfFields() const {
     return numberOfFields;
 }
 
+/**
+ * @brief Gets the type
+ * 
+ * This function gets the type in the flattened type.
+ * 
+ * @return The type in the flattened type
+ */ 
 Type* FlattenedType::getType() const {
     return type;
 }
 
+/**
+ * @brief Gets the fields reverse
+ * 
+ * This function gets the fields reverse in the flattened type.
+ * 
+ * @return The fields reverse in the flattened type
+ */  
 FieldDefinition*** FlattenedType::getFieldsReverse() {
     return fieldsReverse;
 }
 
+/**
+ * @brief Gets the field definition by index
+ * 
+ * This function gets the field definition by index in the flattened type.
+ * 
+ * @param idx The index of the field definition to get  
+ * @return The field definition by index in the flattened type
+ */  
 FieldDefinition* FlattenedType::getFieldDefinitionIdByIndex(short idx) {
     return fieldsReverse[idx][0];
 }

src/fields/flattened_type.cpp

@@ -10,6 +10,7 @@
 #include "fields/subtraction.h"
 #include "fields/test_type.h"
 #include "fields/test_object.h"
+#include "fields/field.h"
 
 
 // ----------------
@@ -64,29 +65,44 @@ PYBIND11_MODULE(aika, m)
                         const_cast<Type*>(&ref),
                         name
                   );
-            }, py::return_value_policy::take_ownership)
+            }, py::return_value_policy::reference_internal)
             .def("sub", [](const Type &ref, const std::string &name) {
                   return new Subtraction(
                         const_cast<Type*>(&ref),
                         name
                   );
-            }, py::return_value_policy::take_ownership);
+            }, py::return_value_policy::reference_internal);
 
       py::class_<Obj>(m, "Obj")
             .def("__str__", [](const Obj &t) {
                   return t.toString();
-            });
+            })
+            .def("setFieldValue", &Obj::setFieldValue)
+            .def("getFieldValue", &Obj::getFieldValue)
+            .def("initFields", &Obj::initFields)
+            .def("getType", &Obj::getType, py::return_value_policy::reference_internal)
+            .def("isInstanceOf", &Obj::isInstanceOf)
+            .def("getFieldOutput", &Obj::getFieldOutput, py::return_value_policy::reference_internal)
+            .def("getOrCreateFieldInput", &Obj::getOrCreateFieldInput, py::return_value_policy::reference_internal);
 
       py::class_<TestType, Type>(m, "TestType")
             .def(py::init<TypeRegistry*, const std::string&>())
-            .def("instantiate", &TestType::instantiate, py::return_value_policy::take_ownership);    
+            .def("instantiate", &TestType::instantiate, py::return_value_policy::reference_internal);    
 
       py::class_<TestObject, Obj>(m, "TestObj")
-            .def(py::init<TestType*>());    
+            .def(py::init<TestType*>())
+            .def_static("linkObjects", &TestObject::linkObjects);    
 
       py::class_<TypeRegistry>(m, "TypeRegistry")
             .def(py::init<>())
             .def("getType", &TypeRegistry::getType)
             .def("registerType", &TypeRegistry::registerType)
             .def("flattenTypeHierarchy", &TypeRegistry::flattenTypeHierarchy);
+
+      py::class_<Field>(m, "Field")
+            .def("getValue", &Field::getValue)
+            .def("getUpdatedValue", &Field::getUpdatedValue)
+            .def("__str__", [](const Field &f) {
+                  return f.toString();
+            });
 }