⏺ The migration appears to be working well with our fixes. Let's summarize what we've done:

  1. Fixed the Phase class to properly implement ProcessingPhase interface
  2. Changed parameter types in method signatures from Timestamp to long
  3. Fixed inconsistencies in const methods across the class hierarchy
  4. Updated isQueued in Fired to use the proper accessor method
  5. Made ElementStep::getPhase() pure virtual to ensure derived classes implement it
  6. Updated all relevant files to maintain consistency

Author: LukasMolzberger

include/fields/step.h

@@ -46,7 +46,7 @@ class Step : public QueueProvider {
     virtual bool incrementRound();
     virtual void createQueueKey(long timestamp, int round) = 0;
     virtual void process() = 0;
-    virtual ProcessingPhase& getPhase() const = 0;
+    virtual const ProcessingPhase& getPhase() const = 0;
     static bool add(Step* s);
 
 };

include/network/activation.h

@@ -11,6 +11,7 @@
 #include "network/bs_type.h"
 #include "network/binding_signal.h"
 #include "network/link.h"
+#include "network/fired.h"
 #include "network/timestamp.h"
 
 #include <map>

include/network/element.h

@@ -2,8 +2,9 @@
 #define NETWORK_ELEMENT_H
 
 #include "network/timestamp.h"
+#include "fields/queue_provider.h"
 
-class Element {
+class Element : public QueueProvider {
 public:
     virtual ~Element() = default;
     virtual Timestamp getCreated() = 0;

include/network/element_step.h

@@ -9,8 +9,9 @@
 class ElementStep : public Step {
 public:
     ElementStep(Element* element);
-    Queue* getQueue() override;
-    void createQueueKey(Timestamp timestamp, int round) override;
+    Queue* getQueue() const override;
+    void createQueueKey(long timestamp, int round) override;
+    virtual const ProcessingPhase& getPhase() const override = 0; // Make this pure virtual for derived classes
     Element* getElement();
     std::string toString() const override;
 

include/network/fired.h

@@ -2,9 +2,9 @@
 #define NETWORK_FIRED_H
 
 #include "fields/step.h"
+#include "fields/queue.h"
 #include "network/activation.h"
 #include "network/phase.h"
-#include "network/queue.h"
 #include "network/timestamp.h"
 #include <string>
 
@@ -13,10 +13,10 @@ class Fired : public Step {
     Fired(Activation* act);
     virtual ~Fired() = default;
 
-    void createQueueKey(Timestamp timestamp, int round) override;
+    void createQueueKey(long timestamp, int round) override;
     void process() override;
     void updateNet(double net);
-    Phase getPhase() const override;
+    const Phase& getPhase() const override;
     Activation* getElement();
     Queue* getQueue() const override;
     std::string toString() const override;

include/network/phase.h

@@ -1,9 +1,10 @@
 #ifndef NETWORK_PHASE_H
 #define NETWORK_PHASE_H
 
-#include "network/processing_phase.h"
+#include "fields/queue_key.h"
 
-enum class Phase : public ProcessingPhase {
+// First define the enum for Phase types
+enum class PhaseType {
     INFERENCE,
     FIRED,
     INSTANTIATION_TRIGGER,
@@ -12,4 +13,45 @@ enum class Phase : public ProcessingPhase {
     SAVE
 };
 
+// Phase class that implements ProcessingPhase interface
+class Phase : public ProcessingPhase {
+public:
+    Phase(PhaseType type) : type(type) {}
+
+    int rank() const override {
+        switch (type) {
+            case PhaseType::INFERENCE: return 0;
+            case PhaseType::FIRED: return 1;
+            case PhaseType::INSTANTIATION_TRIGGER: return 2;
+            case PhaseType::TRAINING: return 3;
+            case PhaseType::INACTIVE_LINKS: return 4;
+            case PhaseType::SAVE: return 5;
+            default: return 0;
+        }
+    }
+
+    bool isDelayed() const override {
+        return type == PhaseType::SAVE; // Only SAVE phase is delayed
+    }
+
+    // Static instances for convenience
+    static const Phase INFERENCE;
+    static const Phase FIRED;
+    static const Phase INSTANTIATION_TRIGGER;
+    static const Phase TRAINING;
+    static const Phase INACTIVE_LINKS;
+    static const Phase SAVE;
+
+private:
+    PhaseType type;
+};
+
+// Define the static instances
+inline const Phase Phase::INFERENCE(PhaseType::INFERENCE);
+inline const Phase Phase::FIRED(PhaseType::FIRED);
+inline const Phase Phase::INSTANTIATION_TRIGGER(PhaseType::INSTANTIATION_TRIGGER);
+inline const Phase Phase::TRAINING(PhaseType::TRAINING);
+inline const Phase Phase::INACTIVE_LINKS(PhaseType::INACTIVE_LINKS);
+inline const Phase Phase::SAVE(PhaseType::SAVE);
+
 #endif // NETWORK_PHASE_H 

include/network/save.h

@@ -1,10 +1,10 @@
 #ifndef NETWORK_SAVE_H
 #define NETWORK_SAVE_H
 
+#include "fields/step.h"
 #include "network/element_step.h"
 #include "network/neuron.h"
 #include "network/phase.h"
-#include "fields/step.h"
 
 class Save : public ElementStep {
 public:
@@ -13,7 +13,7 @@ class Save : public ElementStep {
     Save(Neuron* n);
     virtual ~Save() = default;
 
-    Phase getPhase() const override;
+    const Phase& getPhase() const override;
     void process() override;
 };
 

src/network/activation.cpp

@@ -167,7 +167,7 @@ void Activation::setFired(Timestamp f) {
     fired = f;
 }
 
-void Activation::updateFiredStep(FieldOutput* net) {
+void Activation::updateFiredStep(Field* net) {
     if (!net->exceedsThreshold() || fired != Timestamp::NOT_SET) {
         return;
     }

src/network/element_step.cpp

@@ -2,11 +2,11 @@
 
 ElementStep::ElementStep(Element* element) : element(element) {}
 
-Queue* ElementStep::getQueue() {
+Queue* ElementStep::getQueue() const {
     return element->getQueue();
 }
 
-void ElementStep::createQueueKey(Timestamp timestamp, int round) {
+void ElementStep::createQueueKey(long timestamp, int round) {
     queueKey = new FiredQueueKey(round, getPhase(), element, timestamp);
 }
 

src/network/fired.cpp

@@ -8,7 +8,7 @@
 
 Fired::Fired(Activation* act) : Step(), act(act), net(0.0), sortValue(0) {}
 
-void Fired::createQueueKey(Timestamp timestamp, int round) {
+void Fired::createQueueKey(long timestamp, int round) {
     queueKey = new FiredQueueKey(round, getPhase(), getElement(), timestamp);
 }
 
@@ -32,7 +32,7 @@ void Fired::updateNet(double net) {
     sortValue = static_cast<int>(net * 1000.0); // Scale to preserve 3 decimals of precision
 }
 
-Phase Fired::getPhase() const {
+const Phase& Fired::getPhase() const {
     return Phase::FIRED;
 }
 
@@ -45,7 +45,7 @@ Queue* Fired::getQueue() const {
 }
 
 bool Fired::isQueued() const {
-    return isQueued;
+    return getIsQueued();
 }
 
 std::string Fired::toString() const {