Implemented followManyRelation and followSingleRelation

LukasMolzberger · LukasMolzberger · commit 41bab9932cfd · 2025-05-12T08:20:29.000+02:00
diff --git a/include/fields/rel_obj_iterator.h b/include/fields/rel_obj_iterator.h
@@ -1,6 +1,8 @@
 #ifndef REL_OBJ_ITERATOR_H
 #define REL_OBJ_ITERATOR_H
 
+#include <vector>
+
 class Obj;
 
 class RelatedObjectIterator {
@@ -31,6 +33,27 @@ class SingleObjectIterator : public RelatedObjectIterator {
     }
 };
 
+class VectorObjectIterator : public RelatedObjectIterator {
+    std::vector<Obj*> _objects;
+    size_t _currentIndex;
+
+public:
+    VectorObjectIterator(const std::vector<Obj*>& objects) 
+        : _objects(objects), _currentIndex(0) {}
+
+    ~VectorObjectIterator() = default;
+
+    bool hasNext() override {
+        return _currentIndex < _objects.size();
+    }
+
+    Obj* next() override {
+        if (!hasNext()) {
+            return nullptr;
+        }
+        return _objects[_currentIndex++];
+    }
+};
 
 template <typename MapType>
 class MapRelObjIterator : public RelatedObjectIterator {
@@ -79,9 +102,20 @@ class SingleObjectIterable : public RelatedObjectIterable {
 public:
     SingleObjectIterable(Obj* obj) : _obj(obj) {}
 
-    SingleObjectIterator* iterator() const {
+    SingleObjectIterator* iterator() const override {
         return new SingleObjectIterator(_obj);
     }
 };
 
+class VectorObjectIterable : public RelatedObjectIterable {
+    std::vector<Obj*> _objects;
+
+public:
+    VectorObjectIterable(const std::vector<Obj*>& objects) : _objects(objects) {}
+
+    VectorObjectIterator* iterator() const override {
+        return new VectorObjectIterator(_objects);
+    }
+};
+
 #endif //REL_OBJ_ITERATOR_H
diff --git a/include/network/activation.h b/include/network/activation.h
@@ -26,6 +26,10 @@ class Activation : public Obj, public Element, public ModelProvider {
     Activation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals);
     virtual ~Activation();
 
+    // Implementation of Obj virtual methods
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    Obj* followSingleRelation(const Relation* rel) override;
+    
     ActivationKey getKey();
     Activation* getParent();
     void addOutputLink(Link* l);
diff --git a/include/network/conjunctive_activation.h b/include/network/conjunctive_activation.h
@@ -9,6 +9,8 @@ class ConjunctiveActivation : public Activation {
     ConjunctiveActivation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals);
     virtual ~ConjunctiveActivation();
 
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    
     void linkIncoming(Activation* excludedInputAct) override;
     void addInputLink(Link* l) override;
     std::vector<Link*> getInputLinks() override;
diff --git a/include/network/conjunctive_synapse.h b/include/network/conjunctive_synapse.h
@@ -8,6 +8,9 @@ class ConjunctiveSynapse : public Synapse {
     ConjunctiveSynapse(SynapseDefinition* type);
     ConjunctiveSynapse(SynapseDefinition* type, Neuron* input, Neuron* output);
 
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    Obj* followSingleRelation(const Relation* rel) override;
+
     void write(DataOutput* out) override;
     void readFields(DataInput* in, TypeRegistry* tr) override;
 
diff --git a/include/network/disjunctive_activation.h b/include/network/disjunctive_activation.h
@@ -9,6 +9,8 @@ class DisjunctiveActivation : public Activation {
     DisjunctiveActivation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals);
     virtual ~DisjunctiveActivation();
 
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    
     void linkIncoming(Activation* excludedInputAct) override;
     void addInputLink(Link* l) override;
     std::vector<Link*> getInputLinks() override;
diff --git a/include/network/disjunctive_synapse.h b/include/network/disjunctive_synapse.h
@@ -8,6 +8,9 @@ class DisjunctiveSynapse : public Synapse {
     DisjunctiveSynapse(SynapseDefinition* type);
     DisjunctiveSynapse(SynapseDefinition* type, Neuron* input, Neuron* output);
 
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    Obj* followSingleRelation(const Relation* rel) override;
+
     void link(Model* m) override;
 
 private:
diff --git a/include/network/inhibitory_activation.h b/include/network/inhibitory_activation.h
@@ -10,6 +10,8 @@ class InhibitoryActivation : public Activation {
 public:
     InhibitoryActivation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType*, BindingSignal*> bindingSignals);
 
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    
     void addInputLink(Link* l) override;
     Link* getInputLink(int bsId);
     int getInputKey(Link* l);
diff --git a/include/network/link.h b/include/network/link.h
@@ -20,8 +20,8 @@ class Link : public Obj, public Element, public ModelProvider {
 public:
     Link(LinkDefinition* type, Synapse* s, Activation* input, Activation* output);
 
-    RelatedObjectIterable* followManyRelation(Relation* rel) override;
-    Obj* followSingleRelation(Relation* rel) override;
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    Obj* followSingleRelation(const Relation* rel) override;
     Timestamp getFired() override;
     Timestamp getCreated() override;
     Synapse* getSynapse();
diff --git a/include/network/neuron.h b/include/network/neuron.h
@@ -19,8 +19,8 @@ class Neuron : public Obj, public Element, public ModelProvider {
     Neuron(NeuronDefinition* type, Model* model, long id);
     Neuron(NeuronDefinition* type, Model* model);
 
-    RelatedObjectIterable* followManyRelation(Relation* rel) override;
-    Obj* followSingleRelation(Relation* rel) override;
+    RelatedObjectIterable* followManyRelation(Relation* rel) const override;
+    Obj* followSingleRelation(const Relation* rel) override;
     long getId() const;
     void updatePropagable(Neuron* n, bool isPropagable);
     void wakeupPropagable();
diff --git a/include/network/synapse.h b/include/network/synapse.h
@@ -23,8 +23,8 @@ class Synapse : public Obj, public Element {
 
     virtual ~Synapse() = default;
 
-    virtual RelatedObjectIterable* followManyRelation(Relation* rel) = 0;
-    virtual Obj* followSingleRelation(Relation* rel) = 0;
+    virtual RelatedObjectIterable* followManyRelation(Relation* rel) const = 0;
+    virtual Obj* followSingleRelation(const Relation* rel) = 0;
 
     int getSynapseId() const;
     void setSynapseId(int synapseId);
diff --git a/src/network/activation.cpp b/src/network/activation.cpp
@@ -1,11 +1,15 @@
 #include "network/activation.h"
+#include "network/direction.h"
+#include "network/input.h"
+#include "network/output.h"
+#include "network/activation_definition.h"
 
 const std::function<bool(Activation*, Activation*)> Activation::ID_COMPARATOR = [](Activation* a1, Activation* a2) {
     return a1->getId() < a2->getId();
 };
 
 Activation::Activation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals)
-    : id(id), neuron(n), doc(doc), bindingSignals(bindingSignals), parent(parent), created(Timestamp::NOT_SET), fired(Timestamp::NOT_SET), firedStep(new Fired(this)) {
+    : Obj(t), id(id), neuron(n), doc(doc), bindingSignals(bindingSignals), parent(parent), created(Timestamp::NOT_SET), fired(Timestamp::NOT_SET), firedStep(new Fired(this)) {
     doc->addActivation(this);
     neuron->updateLastUsed(doc->getId());
     setCreated(doc->getCurrentTimestamp());
@@ -15,6 +19,35 @@ Activation::~Activation() {
     delete firedStep;
 }
 
+RelatedObjectIterable* Activation::followManyRelation(Relation* rel) const {
+    // Create a custom iterable for each relation type
+    if (rel->getRelationName() == "INPUT") {
+        // Since getInputLinks() is pure virtual, derived classes should implement specialized behavior
+        // This base implementation handles the common case for OUTPUT relations
+        return nullptr;
+    } else if (rel->getRelationName() == "OUTPUT") {
+        // Convert getOutputLinks() vector to an iterable
+        std::vector<Link*> links = const_cast<Activation*>(this)->getOutputLinks();
+        std::vector<Obj*> objs;
+        for (Link* link : links) {
+            objs.push_back(static_cast<Obj*>(link));
+        }
+        return new VectorObjectIterable(objs);
+    } else {
+        throw std::runtime_error("Invalid Relation: " + rel->getRelationName());
+    }
+}
+
+Obj* Activation::followSingleRelation(const Relation* rel) {
+    if (rel->getRelationName() == "SELF") {
+        return this;
+    } else if (rel->getRelationName() == "NEURON") {
+        return neuron;
+    } else {
+        throw std::runtime_error("Invalid Relation");
+    }
+}
+
 ActivationKey Activation::getKey() {
     return ActivationKey(neuron->getId(), id);
 }
diff --git a/src/network/conjunctive_activation.cpp b/src/network/conjunctive_activation.cpp
@@ -1,12 +1,28 @@
 #include "network/conjunctive_activation.h"
 #include "network/synapse.h"
 #include "network/synapse_definition.h"
+#include "fields/relation.h"
+#include "fields/rel_obj_iterator.h"
 
 ConjunctiveActivation::ConjunctiveActivation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals)
     : Activation(t, parent, id, n, doc, bindingSignals) {}
 
 ConjunctiveActivation::~ConjunctiveActivation() {}
 
+RelatedObjectIterable* ConjunctiveActivation::followManyRelation(Relation* rel) const {
+    if (rel->getRelationName() == "INPUT") {
+        // Convert inputLinks to a vector of Obj*
+        std::vector<Obj*> objs;
+        for (const auto& pair : inputLinks) {
+            objs.push_back(static_cast<Obj*>(pair.second));
+        }
+        return new VectorObjectIterable(objs);
+    } else {
+        // Use base class implementation for other relations
+        return Activation::followManyRelation(rel);
+    }
+}
+
 void ConjunctiveActivation::linkIncoming(Activation* excludedInputAct) {
     for (auto& s : neuron->getInputSynapsesAsStream()) {
         if (static_cast<SynapseDefinition*>(s->getType())->isIncomingLinkingCandidate(getBindingSignals().keySet())) {
diff --git a/src/network/conjunctive_synapse.cpp b/src/network/conjunctive_synapse.cpp
@@ -1,9 +1,28 @@
 #include "network/conjunctive_synapse.h"
+#include "fields/relation.h"
+#include "fields/rel_obj_iterator.h"
 
 ConjunctiveSynapse::ConjunctiveSynapse(SynapseDefinition* type) : Synapse(type), propagable(false) {}
 
 ConjunctiveSynapse::ConjunctiveSynapse(SynapseDefinition* type, Neuron* input, Neuron* output) : Synapse(type, input, output), propagable(false) {}
 
+RelatedObjectIterable* ConjunctiveSynapse::followManyRelation(Relation* rel) const {
+    // Typically synapses don't have "many" relationships
+    throw std::runtime_error("Invalid Relation for ConjunctiveSynapse: " + rel->getRelationName());
+}
+
+Obj* ConjunctiveSynapse::followSingleRelation(const Relation* rel) {
+    if (rel->getRelationName() == "SELF") {
+        return this;
+    } else if (rel->getRelationName() == "INPUT") {
+        return getInput();
+    } else if (rel->getRelationName() == "OUTPUT") {
+        return getOutput();
+    } else {
+        throw std::runtime_error("Invalid Relation for ConjunctiveSynapse: " + rel->getRelationName());
+    }
+}
+
 void ConjunctiveSynapse::write(DataOutput* out) {
     Synapse::write(out);
     out->writeBoolean(propagable);
diff --git a/src/network/disjunctive_activation.cpp b/src/network/disjunctive_activation.cpp
@@ -1,10 +1,26 @@
 #include "network/disjunctive_activation.h"
+#include "fields/relation.h"
+#include "fields/rel_obj_iterator.h"
 
 DisjunctiveActivation::DisjunctiveActivation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals)
     : Activation(t, parent, id, n, doc, bindingSignals) {}
 
 DisjunctiveActivation::~DisjunctiveActivation() {}
 
+RelatedObjectIterable* DisjunctiveActivation::followManyRelation(Relation* rel) const {
+    if (rel->getRelationName() == "INPUT") {
+        // Convert inputLinks to a vector of Obj*
+        std::vector<Obj*> objs;
+        for (const auto& pair : inputLinks) {
+            objs.push_back(static_cast<Obj*>(pair.second));
+        }
+        return new VectorObjectIterable(objs);
+    } else {
+        // Use base class implementation for other relations
+        return Activation::followManyRelation(rel);
+    }
+}
+
 void DisjunctiveActivation::linkIncoming(Activation* excludedInputAct) {
     // Implementation for linking incoming activations
 }
diff --git a/src/network/disjunctive_synapse.cpp b/src/network/disjunctive_synapse.cpp
@@ -1,9 +1,28 @@
 #include "network/disjunctive_synapse.h"
+#include "fields/relation.h"
+#include "fields/rel_obj_iterator.h"
 
 DisjunctiveSynapse::DisjunctiveSynapse(SynapseDefinition* type) : Synapse(type), propagable(true) {}
 
 DisjunctiveSynapse::DisjunctiveSynapse(SynapseDefinition* type, Neuron* input, Neuron* output) : Synapse(type, input, output), propagable(true) {}
 
+RelatedObjectIterable* DisjunctiveSynapse::followManyRelation(Relation* rel) const {
+    // Typically synapses don't have "many" relationships
+    throw std::runtime_error("Invalid Relation for DisjunctiveSynapse: " + rel->getRelationName());
+}
+
+Obj* DisjunctiveSynapse::followSingleRelation(const Relation* rel) {
+    if (rel->getRelationName() == "SELF") {
+        return this;
+    } else if (rel->getRelationName() == "INPUT") {
+        return getInput();
+    } else if (rel->getRelationName() == "OUTPUT") {
+        return getOutput();
+    } else {
+        throw std::runtime_error("Invalid Relation for DisjunctiveSynapse: " + rel->getRelationName());
+    }
+}
+
 void DisjunctiveSynapse::link(Model* m) {
     getInput(m)->addOutputSynapse(this);
 } 
diff --git a/src/network/inhibitory_activation.cpp b/src/network/inhibitory_activation.cpp
@@ -2,9 +2,32 @@
 #include "network/activation_definition.h"
 #include "network/synapse_definition.h"
 #include "network/binding_signal.h"
+#include "fields/relation.h"
+#include "fields/rel_obj_iterator.h"
 
 InhibitoryActivation::InhibitoryActivation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType*, BindingSignal*> bindingSignals)
     : Activation(t, parent, id, n, doc, bindingSignals) {}
+    
+RelatedObjectIterable* InhibitoryActivation::followManyRelation(Relation* rel) const {
+    if (rel->getRelationName() == "INPUT") {
+        // Convert inputLinks to a vector of Obj*
+        std::vector<Obj*> objs;
+        for (const auto& pair : inputLinks) {
+            objs.push_back(static_cast<Obj*>(pair.second));
+        }
+        return new VectorObjectIterable(objs);
+    } else if (rel->getRelationName() == "OUTPUT") {
+        // For InhibitoryActivation, we override both INPUT and OUTPUT handling
+        std::vector<Obj*> objs;
+        for (const auto& pair : outputLinks) {
+            objs.push_back(static_cast<Obj*>(pair.second));
+        }
+        return new VectorObjectIterable(objs);
+    } else {
+        // Use base class implementation for other relations
+        return Activation::followManyRelation(rel);
+    }
+}
 
 void InhibitoryActivation::addInputLink(Link* l) {
     int bsId = getInputKey(l);
diff --git a/src/network/link.cpp b/src/network/link.cpp
@@ -17,18 +17,18 @@ Link::Link(LinkDefinition* type, Synapse* s, Activation* input, Activation* outp
     output->addInputLink(this);
 }
 
-Stream<Obj*> Link::followManyRelation(Relation* rel) {
-    throw std::runtime_error("Invalid Relation");
-}
-
-Obj* Link::followSingleRelation(Relation* rel) {
-    if (rel == SELF) return this;
-    if (rel == LinkDefinition::INPUT) return input;
-    if (rel == LinkDefinition::OUTPUT) return output;
-    if (rel == LinkDefinition::SYNAPSE) return synapse;
-    if (rel == LinkDefinition::CORRESPONDING_INPUT_LINK) return input->getCorrespondingInputLink(this);
-    if (rel == LinkDefinition::CORRESPONDING_OUTPUT_LINK) return output->getCorrespondingOutputLink(this);
-    throw std::runtime_error("Invalid Relation");
+RelatedObjectIterable* Link::followManyRelation(Relation* rel) const {
+    throw std::runtime_error("Invalid Relation: " + rel->getRelationName());
+}
+
+Obj* Link::followSingleRelation(const Relation* rel) {
+    if (rel->getRelationName() == "SELF") return this;
+    if (rel->getRelationName() == "INPUT") return input;
+    if (rel->getRelationName() == "OUTPUT") return output;
+    if (rel->getRelationName() == "SYNAPSE") return synapse;
+    if (rel->getRelationName() == "CORRESPONDING_INPUT_LINK") return input->getCorrespondingInputLink(this);
+    if (rel->getRelationName() == "CORRESPONDING_OUTPUT_LINK") return output->getCorrespondingOutputLink(this);
+    throw std::runtime_error("Invalid Relation: " + rel->getRelationName());
 }
 
 Timestamp Link::getFired() {
diff --git a/src/network/neuron.cpp b/src/network/neuron.cpp
