To summarize the changes:

  1. For the Fired class:
    - Updated the class to properly inherit from Step
    - Fixed the createQueueKey method to use FiredQueueKey
    - Implemented the updateNet method to handle numeric conversion without ApproximateComparisonValueUtil
    - Fixed the toString method to properly format doubles
    - Added proper const qualifiers to methods
  2. For the Save class:
    - Updated the class to properly inherit from ElementStep
    - Fixed the process method to properly cast the Element to Neuron
    - Added proper const qualifiers to methods

Author: LukasMolzberger

include/network/activation.h

@@ -51,7 +51,7 @@ class Activation : public Obj, public Element, public ModelProvider {
     Timestamp getFired();
     void setFired();
     void setFired(Timestamp f);
-    void updateFiredStep(FieldOutput* net);
+    void updateFiredStep(Field* net);
     Queue* getQueue();
     Neuron* getNeuron();
     Document* getDocument();

include/network/fired.h

@@ -5,19 +5,22 @@
 #include "network/activation.h"
 #include "network/phase.h"
 #include "network/queue.h"
+#include "network/timestamp.h"
 #include <string>
 
-class Fired : public Step<Activation> {
+class Fired : public Step {
 public:
     Fired(Activation* act);
+    virtual ~Fired() = default;
 
     void createQueueKey(Timestamp timestamp, int round) override;
     void process() override;
     void updateNet(double net);
-    Phase getPhase() override;
-    Activation* getElement() override;
-    Queue* getQueue() override;
-    std::string toString() override;
+    Phase getPhase() const override;
+    Activation* getElement();
+    Queue* getQueue() const override;
+    std::string toString() const override;
+    bool isQueued() const;
 
 private:
     Activation* act;

include/network/save.h

@@ -4,14 +4,16 @@
 #include "network/element_step.h"
 #include "network/neuron.h"
 #include "network/phase.h"
+#include "fields/step.h"
 
-class Save : public ElementStep<Neuron> {
+class Save : public ElementStep {
 public:
     static void add(Neuron* n);
 
     Save(Neuron* n);
+    virtual ~Save() = default;
 
-    Phase getPhase() override;
+    Phase getPhase() const override;
     void process() override;
 };
 

src/network/fired.cpp

@@ -1,16 +1,20 @@
 #include "network/fired.h"
 #include "network/activation.h"
-#include "network/field_queue_key.h"
-#include "network/approximate_comparison_value_util.h"
-#include "network/string_utils.h"
+#include "fields/queue_key.h"
+#include "network/fired_queue_key.h"
+#include <string>
+#include <sstream>
+#include <iomanip>
 
-Fired::Fired(Activation* act) : act(act), net(0.0), sortValue(0) {}
+Fired::Fired(Activation* act) : Step(), act(act), net(0.0), sortValue(0) {}
 
 void Fired::createQueueKey(Timestamp timestamp, int round) {
-    queueKey = new FieldQueueKey(round, getPhase(), sortValue, timestamp);
+    queueKey = new FiredQueueKey(round, getPhase(), getElement(), timestamp);
 }
 
 void Fired::process() {
+    Activation* act = getElement();
+    
     act->setFired();
 
     // Only once the activation is fired, will it be visible to other neurons.
@@ -23,21 +27,30 @@ void Fired::process() {
 
 void Fired::updateNet(double net) {
     this->net = net;
-    sortValue = ApproximateComparisonValueUtil::convert(net);
+    // Simple conversion to int for sort value (handles approximate comparison)
+    // The original Java uses ApproximateComparisonValueUtil
+    sortValue = static_cast<int>(net * 1000.0); // Scale to preserve 3 decimals of precision
 }
 
-Phase Fired::getPhase() {
+Phase Fired::getPhase() const {
     return Phase::FIRED;
 }
 
 Activation* Fired::getElement() {
     return act;
 }
 
-Queue* Fired::getQueue() {
+Queue* Fired::getQueue() const {
     return act->getDocument();
 }
 
-std::string Fired::toString() {
-    return std::to_string(getElement()) + " net:" + StringUtils::doubleToString(net);
+bool Fired::isQueued() const {
+    return isQueued;
+}
+
+std::string Fired::toString() const {
+    // Format the double with fixed precision (3 decimal places)
+    std::ostringstream ss;
+    ss << std::fixed << std::setprecision(3) << net;
+    return getElement()->toString() + " net:" + ss.str();
 } 

src/network/save.cpp

@@ -1,15 +1,18 @@
 #include "network/save.h"
+#include "fields/step.h"
 
 void Save::add(Neuron* n) {
     Step::add(new Save(n));
 }
 
 Save::Save(Neuron* n) : ElementStep(n) {}
 
-Phase Save::getPhase() {
+Phase Save::getPhase() const {
     return Phase::SAVE;
 }
 
 void Save::process() {
-    getElement()->save();
+    // Cast the Element* to Neuron* before calling save()
+    Neuron* neuron = static_cast<Neuron*>(getElement());
+    neuron->save();
 }