Work on flatten type

LukasMolzberger · LukasMolzberger · commit 0a51f177a2d8 · 2025-04-14T18:10:29.000+02:00
diff --git a/include/fields/direction.h b/include/fields/direction.h
@@ -11,6 +11,7 @@
 #define DIRECTION_H
 
 #include <vector>
+#include <string>
 
 class Obj;
 class Field;
@@ -50,13 +51,15 @@ class Direction {
      */
     virtual int getDirectionId() const = 0;
 
+    virtual std::string getName() const = 0;
+
+
     /**
      * @brief Gets the inverse direction
      * 
      * @return The opposite direction
      */
     virtual Direction* invert() const = 0;
-
     /**
      * @brief Gets the link definition for a field
      * 
@@ -99,6 +102,7 @@ class Direction {
 class Input : public Direction {
 public:
     int getDirectionId() const override;
+    std::string getName() const override;
     Direction* invert() const override;
     std::vector<FieldLinkDefinition*> getFieldLinkDefinitions(FieldDefinition* fd) const override;
     FlattenedType* getFlattenedType(Type* type) const override;
@@ -117,6 +121,7 @@ class Input : public Direction {
 class Output : public Direction {
 public:
     int getDirectionId() const override;
+    std::string getName() const override;
     Direction* invert() const override;
     std::vector<FieldLinkDefinition*> getFieldLinkDefinitions(FieldDefinition* fd) const override;
     FlattenedType* getFlattenedType(Type* type) const override;
diff --git a/include/fields/field_link_definition.h b/include/fields/field_link_definition.h
@@ -132,7 +132,10 @@ class FieldLinkDefinition {
      * 
      * @return The argument position
      */
-    int getArgument() const;
+     std::optional<int> getArgument() const;
+
+     std::string getArgumentAsString() const;
+
 
     /**
      * @brief Gets the input field for a given object
diff --git a/include/fields/flattened_type.h b/include/fields/flattened_type.h
@@ -57,6 +57,7 @@ class FlattenedType {
     int getFieldIndex(FieldDefinition* fd);
     int getNumberOfFields() const;
     Type* getType() const;
+    Direction* getDirection() const;
 
     FieldDefinition*** getFieldsReverse();
     FieldDefinition* getFieldDefinitionIdByIndex(short idx);
diff --git a/include/fields/obj.h b/include/fields/obj.h
@@ -21,7 +21,8 @@ class Obj : public QueueProvider {
     virtual RelatedObjectIterable* followManyRelation(Relation* rel) const = 0;
     virtual Obj* followSingleRelation(const Relation* rel) = 0;
     bool isInstanceOf(Type* t);
-    Field* getFieldOutput(FieldDefinition* fd);
+    Field* getFieldInput(FieldDefinition* fd) const;
+    Field* getFieldOutput(FieldDefinition* fd) const;
     Field* getOrCreateFieldInput(FieldDefinition* fd);
     Obj& setFieldValue(FieldDefinition* fd, double v);
     double getFieldValue(FieldDefinition* fd);
@@ -30,6 +31,7 @@ class Obj : public QueueProvider {
 
     std::string toKeyString();
     std::string toString() const;
+    std::string getFieldAsString(FieldDefinition* fd) const;
 };
 
 #endif // OBJ_H
diff --git a/python-tests/subtraction-test.py b/python-tests/subtraction-test.py
@@ -51,23 +51,31 @@ def testSubtraction(self, linking_pos, test_name):
         oa = typeA.instantiate()
         ob = typeB.instantiate()
 
+        print("linking_pos:", linking_pos)
+
         if linking_pos == 0:
             aika.TestObj.linkObjects(oa, ob)
             ob.initFields()
 
         oa.setFieldValue(a, 50.0)
+        print("oa.getFieldValue(a):", oa.getFieldValue(a))
 
         if linking_pos == 1:
             aika.TestObj.linkObjects(oa, ob)
             ob.initFields()
 
         oa.setFieldValue(b, 20.0)
+        print("oa.getFieldValue(b):", oa.getFieldValue(b))
 
         if linking_pos == 2:
             aika.TestObj.linkObjects(oa, ob)
             ob.initFields()
 
-        self.assertEqual(30.0, ob.getFieldOutput(c).getValue())
+        print("ob.getFieldValue(c):", ob.getFieldValue(c))
+
+        print("ob.getFieldAsString(c):", ob.getFieldAsString(c))
+
+        self.assertEqual(30.0, ob.getFieldValue(b))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/src/fields/direction.cpp b/src/fields/direction.cpp
@@ -24,6 +24,10 @@ int Input::getDirectionId() const {
     return 0; // Return 0 for the "input" direction
 }
 
+std::string Input::getName() const {
+    return "input"; // Return the name of the input direction
+}
+
 Direction* Input::invert() const {
     return Direction::OUTPUT; // Return the OUTPUT direction
 }
@@ -48,6 +52,10 @@ int Output::getDirectionId() const {
     return 1; // Return 1 for the "output" direction
 }
 
+std::string Output::getName() const {
+    return "output"; // Return the name of the output direction
+}
+
 Direction* Output::invert() const {
     return Direction::INPUT; // Return the INPUT direction as the inverse
 }
diff --git a/src/fields/field.cpp b/src/fields/field.cpp
@@ -217,9 +217,7 @@ void Field::receiveUpdate(double u) {
  * @return String representation in the format "name: value"
  */
 std::string Field::toString() const {
-    std::stringstream ss;
-    ss << getName() << ": " << getValueString();
-    return ss.str();
+    return getName() + ": " + getValueString();
 }
 
 /**
@@ -228,5 +226,5 @@ std::string Field::toString() const {
  * @return Value string representation
  */
 std::string Field::getValueString() const {
-    return toString();
+    return std::to_string(value);
 }
diff --git a/src/fields/field_definition.cpp b/src/fields/field_definition.cpp
@@ -33,7 +33,7 @@ FieldDefinition::FieldDefinition(Type* objectType, const std::string& name, int
     objectType->setFieldDefinition(this);
 
     if (numArgs > 0) {
-        inputs.reserve(numArgs);
+        inputs.resize(numArgs);
     }
 }
 
@@ -148,6 +148,11 @@ FieldDefinition* FieldDefinition::resolveInheritedFieldDefinition(const std::set
  * @param field The field to initialize
  */
 void FieldDefinition::initializeField(Field* field) {
+    std::cout << "Initializing field " << std::endl;
+    std::cout << "Field " << field << std::endl;
+    std::cout << "Field object type " << field->getObject()->getType() << std::endl;
+    std::cout << "Field object type flattened type input side " << field->getObject()->getType()->getFlattenedTypeInputSide() << std::endl;
+
     field->getObject()->getType()->getFlattenedTypeInputSide()->followLinks(field);
 }
 
@@ -159,10 +164,20 @@ void FieldDefinition::initializeField(Field* field) {
  * @param fl The field link to add
  */
 void FieldDefinition::addInput(FieldLinkDefinition* fl) {
-    if(fl->getArgument() >= 0) 
-        inputs[fl->getArgument()] = fl;
-    else
-        inputs.push_back(fl);    
+    std::cout << "Adding input " << fl->toString() << std::endl;
+    std::cout << " Argument:" << fl->getArgumentAsString() << std::endl;
+
+    if (fl->getArgument().has_value()) {
+        int arg = fl->getArgument().value();
+        if (arg >= inputs.size()) {
+            inputs.resize(arg + 1);
+        }
+        inputs[arg] = fl;
+    } else {
+        inputs.push_back(fl);
+    }
+
+    std::cout << " Number of inputs:" << getInputs().size() << std::endl;
 }
 
 /**
diff --git a/src/fields/field_link_definition.cpp b/src/fields/field_link_definition.cpp
@@ -112,8 +112,22 @@ Direction* FieldLinkDefinition::getDirection() const {
  * 
  * @return The argument position
  */
-int FieldLinkDefinition::getArgument() const {
-    return argument.value_or(0);
+std::optional<int> FieldLinkDefinition::getArgument() const {
+    return argument;
+}
+
+/**
+ * @brief Gets the argument as a string
+ * 
+ * Returns "no argument" if no argument position is set.
+ * 
+ * @return The argument position as a string
+ */
+std::string FieldLinkDefinition::getArgumentAsString() const {
+    if (argument) {
+        return std::to_string(argument.value());
+    }
+    return "no argument";
 }
 
 /**
@@ -122,8 +136,7 @@ int FieldLinkDefinition::getArgument() const {
  * @return String representation
  */
 std::string FieldLinkDefinition::toString() const {
-    // TODO: Implement proper string representation
-    return "";
+    return "FieldLinkDefinition(" + originFD->getName() + " -> " + relatedFD->getName() + ")";
 }
 
 /**
diff --git a/src/fields/flattened_type.cpp b/src/fields/flattened_type.cpp
@@ -125,6 +125,8 @@ void FlattenedType::flatten() {
     mapping = new FlattenedTypeRelation**[type->getRelations().size()];
 
     for (const auto& rel : type->getRelations()) {
+        std::cout << "FlattenedType::flatten rel " << rel->getRelationLabel() << std::endl;
+
         std::vector<FlattenedTypeRelation*> resultsPerRelation(type->getTypeRegistry()->getTypes().size());
         for (const auto& relatedType : type->getTypeRegistry()->getTypes()) {
             resultsPerRelation[relatedType->getId()] = flattenPerType(rel, relatedType);
@@ -155,6 +157,8 @@ void FlattenedType::flatten() {
 FlattenedTypeRelation* FlattenedType::flattenPerType(Relation* relation, Type* relatedType) {
     std::vector<FieldLinkDefinition*> fieldLinks;
 
+    std::cout << "FlattenedType::flattenPerType begin " << relation->getRelationLabel() << " " << relatedType->getName() << std::endl;
+    
     for (int i = 0; i < numberOfFields; i++) {
         FieldDefinition** fdArray = fieldsReverse[i];
 
@@ -172,6 +176,8 @@ FlattenedTypeRelation* FlattenedType::flattenPerType(Relation* relation, Type* r
                 }
             }
        }
+
+       std::cout << "FlattenedType::flattenPerType end fieldLinks " << fieldLinks.size() << std::endl;
     }
 
     return fieldLinks.empty() ?
@@ -198,6 +204,7 @@ void FlattenedType::followLinks(Field* field) {
             auto it = iterable->iterator();
             while (it->hasNext()) {
                 auto relatedObj = it->next();
+
                 followLinks(ftr[relatedObj->getType()->getId()], relatedObj, field);
             }
             delete it;
@@ -257,6 +264,17 @@ Type* FlattenedType::getType() const {
     return type;
 }
 
+/**
+ * @brief Gets the direction
+ * 
+ * This function gets the direction in the flattened type.
+ * 
+ * @return The direction in the flattened type
+ */ 
+Direction* FlattenedType::getDirection() const {
+    return direction;
+}
+
 /**
  * @brief Gets the fields reverse
  * 
diff --git a/src/fields/flattened_type_relation.cpp b/src/fields/flattened_type_relation.cpp
@@ -4,6 +4,7 @@
 #include "fields/null_terminated_array.h"
 
 FlattenedTypeRelation::FlattenedTypeRelation(FlattenedType* ft, const std::vector<FieldLinkDefinition*>& fls) {
+    std::cout << "  FlattenedTypeRelation constructor " << ft->getType()->getName() << " " << ft->getDirection()->getName() << std::endl;
     flattenedType = ft;
 
     std::map<int, std::vector<FieldLinkDefinition*>*> groupedByOriginFD;
@@ -21,31 +22,55 @@ FlattenedTypeRelation::FlattenedTypeRelation(FlattenedType* ft, const std::vecto
     // Initialize fieldLinks to the correct size
     fieldLinks = new FieldLinkDefinition**[flattenedType->getNumberOfFields()];
 
+    std::cout << "  FlattenedTypeRelation constructor NumberOfFields " << flattenedType->getNumberOfFields() << std::endl;
+
     // Fill fieldLinks with the grouped FieldLinkDefinitions
     for (int i = 0; i < flattenedType->getNumberOfFields(); ++i) {
         FieldDefinition** fdArray = flattenedType->getFieldsReverse()[i];
 
+        std::cout << "  FlattenedTypeRelation constructor fdArray " << fdArray << std::endl;
+
         int j = 0;
         while (fdArray[j] != nullptr) {
             FieldDefinition* fd = fdArray[j];
             j++;
 
+            std::cout << "  FlattenedTypeRelation constructor fd " << fd << std::endl;
+
             std::vector<FieldLinkDefinition*>* fls = groupedByOriginFD[fd->getId()];
+            std::cout << "  FlattenedTypeRelation constructor fls " << fls << std::endl;
+
             if(fls != nullptr) {
                 fieldLinks[i] = nullTerminatedArrayFromVector<FieldLinkDefinition*>(*fls);
+
+                std::cout << "  FlattenedTypeRelation constructor fieldLinks[" << i << "] " << fieldLinks[i] << std::endl;
             }
         }
     }
+
+    std::cout << "  FlattenedTypeRelation constructor end " << std::endl;
 }
 
 void FlattenedTypeRelation::followLinks(Direction* direction, Obj* relatedObj, Field* field) {
+    std::cout << "followLinks field " << field << std::endl;
+    std::cout << "followLinks field->getId() " << field->getId() << std::endl;
+    std::cout << "followLinks field->getName() " << field->getName() << std::endl;
+    std::cout << "followLinks fieldLinks[field->getId()] " << fieldLinks[field->getId()] << std::endl;
+    
     FieldLinkDefinition** flArray = fieldLinks[field->getId()];
 
+     std::cout << "followLinks flArray " << flArray << std::endl;
+
     int i = 0;
     while (flArray[i] != nullptr) {
         FieldLinkDefinition* fl = flArray[i];
+        std::cout << "Following links for relation B " << fl << std::endl;
+        std::cout << "fl->getOriginFD() " << fl->getOriginFD() << std::endl;
+        std::cout << "fl->getOriginFD()->getId() " << fl->getOriginFD()->getId() << std::endl;
         i++;
 
+        std::cout << "transmit " << field << " " << fl << " " << relatedObj << std::endl;
         direction->transmit(field, fl, relatedObj);
     }
+    std::cout << "followLinks end " << std::endl;
 }
diff --git a/src/fields/obj.cpp b/src/fields/obj.cpp
diff --git a/src/fields/python_bindings.cpp b/src/fields/python_bindings.cpp
diff --git a/src/fields/type_registry.cpp b/src/fields/type_registry.cpp

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,10 @@ int Input::getDirectionId() const {`
`24`	`24`	`return 0; // Return 0 for the "input" direction`
`25`	`25`	`}`
`26`	`26`
	`27`	`+std::string Input::getName() const {`
	`28`	`+ return "input"; // Return the name of the input direction`
	`29`	`+}`
	`30`	`+`
`27`	`31`	`Direction* Input::invert() const {`
`28`	`32`	`return Direction::OUTPUT; // Return the OUTPUT direction`
`29`	`33`	`}`
`@@ -48,6 +52,10 @@ int Output::getDirectionId() const {`
`48`	`52`	`return 1; // Return 1 for the "output" direction`
`49`	`53`	`}`
`50`	`54`
	`55`	`+std::string Output::getName() const {`
	`56`	`+ return "output"; // Return the name of the output direction`
	`57`	`+}`
	`58`	`+`
`51`	`59`	`Direction* Output::invert() const {`
`52`	`60`	`return Direction::INPUT; // Return the INPUT direction as the inverse`
`53`	`61`	`}`