1. Removed the Timestamp class and replaced it with primitive long types

  2. Created a minimal timestamp.h header for backward compatibility with NOT_SET defined as -1
  3. Updated all method signatures and implementations to use long instead of Timestamp
  4. Fixed comparisons with NOT_SET to use -1 directly
  5. Updated the Phase class to properly implement the ProcessingPhase interface
  6. Added proper toString() method to the Phase class for easier debugging

Author: LukasMolzberger

include/network/activation.h

@@ -12,7 +12,6 @@
 #include "network/binding_signal.h"
 #include "network/link.h"
 #include "network/fired.h"
-#include "network/timestamp.h"
 
 #include <map>
 #include <set>
@@ -47,11 +46,11 @@ class Activation : public Obj, public Element, public ModelProvider {
     virtual void linkIncoming(Activation* excludedInputAct) = 0;
     std::set<Activation*> collectLinkingTargets(Neuron* n);
     int getId();
-    Timestamp getCreated();
-    void setCreated(Timestamp ts);
-    Timestamp getFired();
+    long getCreated() override;
+    void setCreated(long ts);
+    long getFired() override;
     void setFired();
-    void setFired(Timestamp f);
+    void setFired(long f);
     void updateFiredStep(Field* net);
     Queue* getQueue();
     Neuron* getNeuron();

include/network/element.h

@@ -1,14 +1,13 @@
 #ifndef NETWORK_ELEMENT_H
 #define NETWORK_ELEMENT_H
 
-#include "network/timestamp.h"
 #include "fields/queue_provider.h"
 
 class Element : public QueueProvider {
 public:
     virtual ~Element() = default;
-    virtual Timestamp getCreated() = 0;
-    virtual Timestamp getFired() = 0;
+    virtual long getCreated() = 0;
+    virtual long getFired() = 0;
 };
 
 #endif // NETWORK_ELEMENT_H 

include/network/fired.h

@@ -5,7 +5,6 @@
 #include "fields/queue.h"
 #include "network/activation.h"
 #include "network/phase.h"
-#include "network/timestamp.h"
 #include <string>
 
 class Fired : public Step {

include/network/fired_queue_key.h

@@ -1,27 +1,25 @@
 #ifndef NETWORK_FIRED_QUEUE_KEY_H
 #define NETWORK_FIRED_QUEUE_KEY_H
 
-#include "network/queue_key.h"
+#include "fields/queue_key.h"
 #include "network/element.h"
-#include "network/processing_phase.h"
-#include "network/timestamp.h"
 #include <string>
 #include <functional>
 
 class FiredQueueKey : public QueueKey {
 public:
-    FiredQueueKey(int round, ProcessingPhase phase, Element* element, Timestamp currentTimestamp);
+    FiredQueueKey(int round, const ProcessingPhase& phase, Element* element, long currentTimestamp);
 
-    Timestamp getFired() const;
-    Timestamp getCreated() const;
+    long getFired() const;
+    long getCreated() const;
     std::string toString() const override;
     int compareTo(QueueKey* qk) const override;
 
 private:
     static const std::function<int(const FiredQueueKey*, const FiredQueueKey*)> COMPARATOR;
 
-    Timestamp created;
-    Timestamp fired;
+    long created;
+    long fired;
 };
 
 #endif // NETWORK_FIRED_QUEUE_KEY_H 

include/network/link.h

@@ -22,8 +22,8 @@ class Link : public Obj, public Element, public ModelProvider {
 
     RelatedObjectIterable* followManyRelation(Relation* rel) const override;
     Obj* followSingleRelation(const Relation* rel) override;
-    Timestamp getFired() override;
-    Timestamp getCreated() override;
+    long getFired() override;
+    long getCreated() override;
     Synapse* getSynapse();
     void setSynapse(Synapse* synapse);
     Activation* getInput();

include/network/neuron.h

@@ -48,8 +48,8 @@ class Neuron : public Obj, public Element, public ModelProvider {
     Synapse* getOutputSynapseByType(Type* synapseType) const;
     std::vector<Synapse*> getOutputSynapsesByType(Type* synapseType) const;
     Synapse* selectInputSynapse(std::function<bool(Synapse*)> predicate) const;
-    Timestamp getCreated() override;
-    Timestamp getFired() override;
+    long getCreated() override;
+    long getFired() override;
     Queue* getQueue() override;
     void increaseRefCount(RefType rt);
     void decreaseRefCount(RefType rt);

include/network/phase.h

@@ -2,6 +2,7 @@
 #define NETWORK_PHASE_H
 
 #include "fields/queue_key.h"
+#include <string>
 
 // First define the enum for Phase types
 enum class PhaseType {
@@ -14,7 +15,7 @@ enum class PhaseType {
 };
 
 // Phase class that implements ProcessingPhase interface
-class Phase : public ProcessingPhase {
+class Phase final : public ProcessingPhase {
 public:
     Phase(PhaseType type) : type(type) {}
 
@@ -34,6 +35,19 @@ class Phase : public ProcessingPhase {
         return type == PhaseType::SAVE; // Only SAVE phase is delayed
     }
 
+    // For string representation
+    std::string toString() const {
+        switch (type) {
+            case PhaseType::INFERENCE: return "INFERENCE";
+            case PhaseType::FIRED: return "FIRED";
+            case PhaseType::INSTANTIATION_TRIGGER: return "INSTANTIATION_TRIGGER";
+            case PhaseType::TRAINING: return "TRAINING";
+            case PhaseType::INACTIVE_LINKS: return "INACTIVE_LINKS";
+            case PhaseType::SAVE: return "SAVE";
+            default: return "UNKNOWN";
+        }
+    }
+
     // Static instances for convenience
     static const Phase INFERENCE;
     static const Phase FIRED;

include/network/synapse.h

@@ -63,8 +63,8 @@ class Synapse : public Obj, public Element {
     virtual void readFields(DataInput* in, TypeRegistry* tr) = 0;
 */
 
-    Timestamp getCreated() const override;
-    Timestamp getFired() const override;
+    long getCreated() const override;
+    long getFired() const override;
 
     void deleteSynapse(Model* m);
 

include/network/timestamp.h

@@ -1,29 +1,11 @@
 #ifndef NETWORK_TIMESTAMP_H
 #define NETWORK_TIMESTAMP_H
 
-#include <string>
+// This is a compatibility header.
+// The Timestamp class has been replaced with direct use of long values.
+// The constant Timestamp::NOT_SET has been replaced with the value -1.
 
-class Timestamp {
-public:
-    static const Timestamp NOT_SET;
+// For backwards compatibility, define NOT_SET as -1
+constexpr long NOT_SET = -1;
 
-    Timestamp();
-    Timestamp(long time);
-
-    long getTime() const;
-    void setTime(long time);
-
-    bool operator==(const Timestamp& other) const;
-    bool operator!=(const Timestamp& other) const;
-    bool operator<(const Timestamp& other) const;
-    bool operator>(const Timestamp& other) const;
-    bool operator<=(const Timestamp& other) const;
-    bool operator>=(const Timestamp& other) const;
-
-    std::string toString() const;
-
-private:
-    long time;
-};
-
-#endif // NETWORK_TIMESTAMP_H 
+#endif // NETWORK_TIMESTAMP_H

src/network/activation.cpp

@@ -9,7 +9,7 @@ const std::function<bool(Activation*, Activation*)> Activation::ID_COMPARATOR =
 };
 
 Activation::Activation(ActivationDefinition* t, Activation* parent, int id, Neuron* n, Document* doc, std::map<BSType, BindingSignal*> bindingSignals)
-    : Obj(t), 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(-1), fired(-1), firedStep(new Fired(this)) {
     doc->addActivation(this);
     neuron->updateLastUsed(doc->getId());
     setCreated(doc->getCurrentTimestamp());
@@ -147,28 +147,28 @@ int Activation::getId() {
     return id;
 }
 
-Timestamp Activation::getCreated() {
+long Activation::getCreated() {
     return created;
 }
 
-void Activation::setCreated(Timestamp ts) {
+void Activation::setCreated(long ts) {
     created = ts;
 }
 
-Timestamp Activation::getFired() {
+long Activation::getFired() {
     return fired;
 }
 
 void Activation::setFired() {
     fired = doc->getCurrentTimestamp();
 }
 
-void Activation::setFired(Timestamp f) {
+void Activation::setFired(long f) {
     fired = f;
 }
 
 void Activation::updateFiredStep(Field* net) {
-    if (!net->exceedsThreshold() || fired != Timestamp::NOT_SET) {
+    if (!net->exceedsThreshold() || fired != -1) {
         return;
     }