From 2283aed5363b3c3a8e93f573f9e9a2211b56669c Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent.lamiraux@laas.fr>
Date: Thu, 15 Jun 2023 16:07:40 +0200
Subject: [PATCH 1/8] Define a specific type for signal time.

---
 include/dynamic-graph/entity.h           | 12 ++++----
 include/dynamic-graph/fwd.hh             |  2 ++
 include/dynamic-graph/pool.h             |  2 +-
 include/dynamic-graph/signal-array.h     |  2 +-
 include/dynamic-graph/signal-helper.h    | 18 ++++++------
 include/dynamic-graph/tracer-real-time.h |  4 +--
 include/dynamic-graph/tracer.h           | 14 ++++-----
 src/dgraph/entity.cpp                    | 36 +++++++++++++-----------
 src/dgraph/pool.cpp                      | 21 +-------------
 src/signal/signal-array.cpp              |  2 +-
 src/traces/tracer-real-time.cpp          |  4 +--
 src/traces/tracer.cpp                    | 18 ++++++------
 tests/debug-real-time-tracer.cpp         | 18 ++++++------
 tests/debug-tracer.cpp                   | 26 +++++++++--------
 tests/entity.cpp                         | 11 ++++----
 tests/pool.cpp                           |  9 +++---
 16 files changed, 95 insertions(+), 104 deletions(-)

diff --git a/include/dynamic-graph/entity.h b/include/dynamic-graph/entity.h
index acb2b86d..2f75bf9b 100644
--- a/include/dynamic-graph/entity.h
+++ b/include/dynamic-graph/entity.h
@@ -51,7 +51,7 @@ namespace dynamicgraph {
 /// DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN macro in factory.h.
 class DYNAMIC_GRAPH_DLLAPI Entity : private boost::noncopyable {
  public:
-  typedef std::map<std::string, SignalBase<int> *> SignalMap;
+  typedef std::map<std::string, SignalBase<sigtime_t> *> SignalMap;
   typedef std::map<const std::string, command::Command *> CommandMap_t;
 
   explicit Entity(const std::string &name);
@@ -76,13 +76,13 @@ class DYNAMIC_GRAPH_DLLAPI Entity : private boost::noncopyable {
       \param signalName: Name of the signal
       \return A reference to the signal with a temporal dependency.
    */
-  SignalBase<int> &getSignal(const std::string &signalName);
+  SignalBase<sigtime_t> &getSignal(const std::string &signalName);
 
   /** \brief Provides a const reference to the signal named signalName.
       \param signalName: Name of the signal
       \return A const reference to the signal with a temporal dependency.
    */
-  const SignalBase<int> &getSignal(const std::string &signalName) const;
+  const SignalBase<sigtime_t> &getSignal(const std::string &signalName) const;
 
   /** \brief Display the list of signals of this entity in output stream os.
       \param os: the output stream where to display the list of signals.
@@ -108,9 +108,9 @@ class DYNAMIC_GRAPH_DLLAPI Entity : private boost::noncopyable {
    */
   virtual void display(std::ostream &os) const;
 
-  virtual SignalBase<int> *test() { return 0; }
+  virtual SignalBase<sigtime_t> *test() { return 0; }
 
-  virtual void test2(SignalBase<int> *) { return; }
+  virtual void test2(SignalBase<sigtime_t> *) { return; }
 
   const std::string &getCommandList() const;
 
@@ -168,7 +168,7 @@ class DYNAMIC_GRAPH_DLLAPI Entity : private boost::noncopyable {
   void entityRegistration();
   void entityDeregistration();
 
-  void signalRegistration(const SignalArray<int> &signals);
+  void signalRegistration(const SignalArray<sigtime_t> &signals);
   void signalDeregistration(const std::string &name);
 
   std::string name;
diff --git a/include/dynamic-graph/fwd.hh b/include/dynamic-graph/fwd.hh
index 54cb3f30..e7541020 100644
--- a/include/dynamic-graph/fwd.hh
+++ b/include/dynamic-graph/fwd.hh
@@ -8,6 +8,8 @@
 #include <boost/smart_ptr.hpp>
 
 namespace dynamicgraph {
+// Set a typedef for signal time type
+typedef int sigtime_t;
 
 // to be replace by std:: when we switch to C++11 and later
 using boost::const_pointer_cast;
diff --git a/include/dynamic-graph/pool.h b/include/dynamic-graph/pool.h
index b9cbd2e8..d7c647f0 100644
--- a/include/dynamic-graph/pool.h
+++ b/include/dynamic-graph/pool.h
@@ -91,7 +91,7 @@ class DYNAMIC_GRAPH_DLLAPI PoolStorage {
   /// \brief Get a signal by name
   ///
   /// \param sigpath stream containing a string of the form "entity.signal"
-  SignalBase<int> &getSignal(std::istringstream &sigpath);
+  SignalBase<sigtime_t> &getSignal(std::istringstream &sigpath);
 
   /*! \brief This method write a graph description on the file named
       FileName. */
diff --git a/include/dynamic-graph/signal-array.h b/include/dynamic-graph/signal-array.h
index 151c5053..15db4b75 100644
--- a/include/dynamic-graph/signal-array.h
+++ b/include/dynamic-graph/signal-array.h
@@ -147,7 +147,7 @@ SignalArray<Time> operator<<(SignalBase<Time> &sig1, SignalBase<Time> &sig2) {
   return res;
 }
 
-DYNAMIC_GRAPH_DLLAPI extern SignalArray<int> sotNOSIGNAL;
+DYNAMIC_GRAPH_DLLAPI extern SignalArray<sigtime_t> sotNOSIGNAL;
 
 }  // end of namespace dynamicgraph.
 
diff --git a/include/dynamic-graph/signal-helper.h b/include/dynamic-graph/signal-helper.h
index c3db75f5..2eb87b5f 100644
--- a/include/dynamic-graph/signal-helper.h
+++ b/include/dynamic-graph/signal-helper.h
@@ -20,7 +20,7 @@
 #define SIGNAL_OUT_FUNCTION_NAME(name) name##SOUT_function
 
 #define DECLARE_SIGNAL(name, IO, type) \
-  ::dynamicgraph::Signal<type, int> m_##name##S##IO
+  ::dynamicgraph::Signal<type, sigtime_t> m_##name##S##IO
 #define CONSTRUCT_SIGNAL(name, IO, type)                                    \
   m_##name##S##IO(getClassName() + "(" + getName() + ")::" + #IO + "put(" + \
                   #type + ")::" + #name)
@@ -31,7 +31,7 @@
 /**/
 
 #define DECLARE_SIGNAL_IN(name, type) \
-  ::dynamicgraph::SignalPtr<type, int> m_##name##SIN
+  ::dynamicgraph::SignalPtr<type, sigtime_t> m_##name##SIN
 #define CONSTRUCT_SIGNAL_IN(name, type)                                        \
   m_##name##SIN(NULL, getClassName() + "(" + getName() + ")::input(" + #type + \
                           ")::" + #name)
@@ -39,19 +39,19 @@
 /**/
 
 #define DECLARE_SIGNAL_OUT_FUNCTION(name, type) \
-  type &SIGNAL_OUT_FUNCTION_NAME(name)(type &, int)
+  type &SIGNAL_OUT_FUNCTION_NAME(name)(type &, sigtime_t)
 
 #define DEFINE_SIGNAL_OUT_FUNCTION(name, type) \
-  type &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name)(type & s, int iter)
+  type &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name)(type & s, sigtime_t iter)
 
 #define SIGNAL_OUT_FUNCTION(name) name##SOUT_function
 
 #define DECLARE_SIGNAL_OUT(name, type)                           \
  public:                                                         \
-  ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SOUT; \
+  ::dynamicgraph::SignalTimeDependent<type, sigtime_t> m_##name##SOUT; \
                                                                  \
  protected:                                                      \
-  type &SIGNAL_OUT_FUNCTION(name)(type &, int)
+  type &SIGNAL_OUT_FUNCTION(name)(type &, sigtime_t)
 
 #define CONSTRUCT_SIGNAL_OUT(name, type, dep)                                \
   m_##name##SOUT(                                                            \
@@ -62,14 +62,14 @@
 #define SIGNAL_INNER_FUNCTION_NAME(name) name##SINNER_function
 
 #define DECLARE_SIGNAL_INNER_FUNCTION(name, type) \
-  type &SIGNAL_INNER_FUNCTION_NAME(name)(type &, int)
+  type &SIGNAL_INNER_FUNCTION_NAME(name)(type &, sigtime_t)
 
 #define DEFINE_SIGNAL_INNER_FUNCTION(name, type) \
-  type &EntityClassName::SIGNAL_INNER_FUNCTION_NAME(name)(type & s, int iter)
+  type &EntityClassName::SIGNAL_INNER_FUNCTION_NAME(name)(type & s, sigtime_t iter)
 
 #define DECLARE_SIGNAL_INNER(name, type)                           \
  public:                                                           \
-  ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SINNER; \
+  ::dynamicgraph::SignalTimeDependent<type, sigtime_t> m_##name##SINNER; \
                                                                    \
  protected:                                                        \
   DECLARE_SIGNAL_INNER_FUNCTION(name, type)
diff --git a/include/dynamic-graph/tracer-real-time.h b/include/dynamic-graph/tracer-real-time.h
index 86816ada..a070ec4d 100644
--- a/include/dynamic-graph/tracer-real-time.h
+++ b/include/dynamic-graph/tracer-real-time.h
@@ -57,10 +57,10 @@ class DG_TRACERREALTIME_DLLAPI TracerRealTime : public Tracer {
   const int &getBufferSize() { return bufferSize; }
 
  protected:
-  virtual void openFile(const SignalBase<int> &sig,
+  virtual void openFile(const SignalBase<sigtime_t> &sig,
                         const std::string &filename);
 
-  virtual void recordSignal(std::ostream &os, const SignalBase<int> &sig);
+  virtual void recordSignal(std::ostream &os, const SignalBase<sigtime_t> &sig);
 
   typedef std::list<std::ofstream *> HardFileList;
   static const int BUFFER_SIZE_DEFAULT = 1048576;  //  1Mo
diff --git a/include/dynamic-graph/tracer.h b/include/dynamic-graph/tracer.h
index d0143184..e2c3c145 100644
--- a/include/dynamic-graph/tracer.h
+++ b/include/dynamic-graph/tracer.h
@@ -25,7 +25,7 @@ class DG_TRACER_DLLAPI Tracer : public Entity {
   DYNAMIC_GRAPH_ENTITY_DECL();
 
  protected:
-  typedef std::list<const SignalBase<int> *> SignalList;
+  typedef std::list<const SignalBase<sigtime_t> *> SignalList;
   SignalList toTraceSignals;
   std::mutex files_mtx;
 
@@ -53,13 +53,13 @@ class DG_TRACER_DLLAPI Tracer : public Entity {
   typedef std::list<std::string> NameList;
   NameList names;
   bool play;
-  int timeStart;
+  sigtime_t timeStart;
 
  public:
   Tracer(const std::string n);
   virtual ~Tracer() { closeFiles(); }
 
-  void addSignalToTrace(const SignalBase<int> &sig,
+  void addSignalToTrace(const SignalBase<sigtime_t> &sig,
                         const std::string &filename = "");
   void addSignalToTraceByName(const std::string &signame,
                               const std::string &filename = "");
@@ -70,7 +70,7 @@ class DG_TRACER_DLLAPI Tracer : public Entity {
   virtual void closeFiles();
 
  protected:
-  virtual void openFile(const SignalBase<int> &sig,
+  virtual void openFile(const SignalBase<sigtime_t> &sig,
                         const std::string &filename);
 
  public:
@@ -81,8 +81,8 @@ class DG_TRACER_DLLAPI Tracer : public Entity {
   double getFrequency() { return frequency; }
 
   void record();
-  virtual void recordSignal(std::ostream &os, const SignalBase<int> &sig);
-  int &recordTrigger(int &dummy, const int &time);
+  virtual void recordSignal(std::ostream &os, const SignalBase<sigtime_t> &sig);
+  sigtime_t &recordTrigger(sigtime_t &dummy, const sigtime_t &time);
 
   virtual void trace();
   void start() { play = true; }
@@ -90,7 +90,7 @@ class DG_TRACER_DLLAPI Tracer : public Entity {
 
  public:
   // SignalTrigerer<int> triger;
-  SignalTimeDependent<int, int> triger;
+  SignalTimeDependent<sigtime_t, sigtime_t> triger;
 
   /* --- DISPLAY --------------------------------------------------------- */
   DG_TRACER_DLLAPI friend std::ostream &operator<<(std::ostream &os,
diff --git a/src/dgraph/entity.cpp b/src/dgraph/entity.cpp
index 3fdbf0ee..05f7f5d2 100644
--- a/src/dgraph/entity.cpp
+++ b/src/dgraph/entity.cpp
@@ -56,9 +56,9 @@ Entity::~Entity() {
 /* -------------------------------------------------------------------------- */
 /* --- SIGNALS -------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
-void Entity::signalRegistration(const SignalArray<int> &signals) {
+void Entity::signalRegistration(const SignalArray<sigtime_t> &signals) {
   for (unsigned int i = 0; i < signals.getSize(); ++i) {
-    SignalBase<int> &sig = signals[i];
+    SignalBase<sigtime_t> &sig = signals[i];
     // const string& signame = sig.getName ();
     istringstream iss(sig.getName());
     const int SIZE = 4096;
@@ -106,26 +106,30 @@ std::string Entity::getDocString() const {
   return docString;
 }
 
-#define __DG_ENTITY_GET_SIGNAL__(ITER_TYPE)                                  \
-  SignalMap::ITER_TYPE sigkey = signalMap.find(signame);                     \
-  if (sigkey == signalMap.end()) /* key does NOT exist */                    \
-  {                                                                          \
-    throw ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL,               \
-                           "The requested signal is not registered", ": %s", \
-                           signame.c_str());                                 \
-  }                                                                          \
-  return *(sigkey->second);
-
 bool Entity::hasSignal(const string &signame) const {
   return (!(signalMap.find(signame) == signalMap.end()));
 }
 
-SignalBase<int> &Entity::getSignal(const string &signame) {
-  __DG_ENTITY_GET_SIGNAL__(iterator);
+SignalBase<sigtime_t> &Entity::getSignal(const string &signame) {
+  SignalMap::iterator sigkey = signalMap.find(signame);
+  if (sigkey == signalMap.end()) /* key does NOT exist */
+  {
+    throw ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL,
+                           "The requested signal is not registered", ": %s",
+                           signame.c_str());
+  }
+  return *(sigkey->second);
 }
 
-const SignalBase<int> &Entity::getSignal(const string &signame) const {
-  __DG_ENTITY_GET_SIGNAL__(const_iterator);
+const SignalBase<sigtime_t> &Entity::getSignal(const string &signame) const {
+  SignalMap::const_iterator sigkey = signalMap.find(signame);
+  if (sigkey == signalMap.end()) /* key does NOT exist */
+  {
+    throw ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL,
+                           "The requested signal is not registered", ": %s",
+                           signame.c_str());
+  }
+  return *(sigkey->second);
 }
 
 std::ostream &Entity::displaySignalList(std::ostream &os) const {
diff --git a/src/dgraph/pool.cpp b/src/dgraph/pool.cpp
index c6a2c01c..60fd1bec 100644
--- a/src/dgraph/pool.cpp
+++ b/src/dgraph/pool.cpp
@@ -138,10 +138,6 @@ void PoolStorage::clearPlugin(const std::string &name) {
 
 #include <dynamic-graph/entity.h>
 
-#ifdef WIN32
-#include <time.h>
-#endif /*WIN32*/
-
 void PoolStorage::writeGraph(const std::string &aFileName) {
   size_t IdxPointFound = aFileName.rfind(".");
   std::string tmp1 = aFileName.substr(0, IdxPointFound);
@@ -152,24 +148,9 @@ void PoolStorage::writeGraph(const std::string &aFileName) {
   else
     GenericName = tmp1;
 
-  /* Reading local time */
-  time_t ltime;
-  ltime = time(NULL);
-  struct tm ltimeformatted;
-#ifdef WIN32
-  localtime_s(&ltimeformatted, &ltime);
-#else
-  localtime_r(&ltime, &ltimeformatted);
-#endif /*WIN32*/
-
   /* Opening the file and writing the first comment. */
   std::ofstream GraphFile(aFileName.c_str(), std::ofstream::out);
   GraphFile << "/* This graph has been automatically generated. " << std::endl;
-  GraphFile << "   " << 1900 + ltimeformatted.tm_year
-            << " Month: " << 1 + ltimeformatted.tm_mon
-            << " Day: " << ltimeformatted.tm_mday
-            << " Time: " << ltimeformatted.tm_hour << ":"
-            << ltimeformatted.tm_min;
   GraphFile << " */" << std::endl;
   GraphFile << "digraph \"" << GenericName << "\" { ";
   GraphFile << "\t graph [ label=\"" << GenericName
@@ -219,7 +200,7 @@ static bool objectNameParser(std::istringstream &cmdparse, std::string &objName,
   return true;
 }
 
-SignalBase<int> &PoolStorage::getSignal(std::istringstream &sigpath) {
+SignalBase<sigtime_t> &PoolStorage::getSignal(std::istringstream &sigpath) {
   std::string objname, signame;
   if (!objectNameParser(sigpath, objname, signame)) {
     DG_THROW ExceptionFactory(ExceptionFactory::UNREFERED_SIGNAL,
diff --git a/src/signal/signal-array.cpp b/src/signal/signal-array.cpp
index f0c9961d..20acfd1f 100644
--- a/src/signal/signal-array.cpp
+++ b/src/signal/signal-array.cpp
@@ -10,5 +10,5 @@
 #include <dynamic-graph/signal-array.h>
 
 namespace dynamicgraph {
-SignalArray<int> sotNOSIGNAL(0);
+SignalArray<sigtime_t> sotNOSIGNAL(0);
 }
diff --git a/src/traces/tracer-real-time.cpp b/src/traces/tracer-real-time.cpp
index cf83e9a2..d6a982c3 100644
--- a/src/traces/tracer-real-time.cpp
+++ b/src/traces/tracer-real-time.cpp
@@ -112,7 +112,7 @@ TracerRealTime::TracerRealTime(const std::string &n)
 /* --------------------------------------------------------------------- */
 /* --------------------------------------------------------------------- */
 
-void TracerRealTime::openFile(const SignalBase<int> &sig,
+void TracerRealTime::openFile(const SignalBase<sigtime_t> &sig,
                               const std::string &givenname) {
   dgDEBUGIN(15);
   string signame;
@@ -229,7 +229,7 @@ void TracerRealTime::emptyBuffers() {
 }
 
 void TracerRealTime::recordSignal(std::ostream &os,
-                                  const SignalBase<int> &sig) {
+                                  const SignalBase<sigtime_t> &sig) {
   dgDEBUGIN(15);
 
   try {
diff --git a/src/traces/tracer.cpp b/src/traces/tracer.cpp
index a6c14e1d..721b3214 100644
--- a/src/traces/tracer.cpp
+++ b/src/traces/tracer.cpp
@@ -44,9 +44,9 @@ Tracer::Tracer(const std::string n)
       names(),
       play(false),
       timeStart(0),
-      triger(boost::bind(&Tracer::recordTrigger, this, _1, _2), sotNOSIGNAL,
-             "Tracer(" + n + ")::triger") {
+      triger("Tracer(" + n + ")::triger") {
   signalRegistration(triger);
+  triger.setFunction(boost::bind(&Tracer::recordTrigger, this, _1, _2));
 
   /* --- Commands --- */
   {
@@ -85,10 +85,10 @@ Tracer::Tracer(const std::string n)
 
     addCommand("getTimeStart",
                makeDirectGetter(*this, &timeStart,
-                                docDirectGetter("timeStart", "int")));
+                                docDirectGetter("timeStart", "long int")));
     addCommand("setTimeStart",
                makeDirectSetter(*this, &timeStart,
-                                docDirectSetter("timeStart", "int")));
+                                docDirectSetter("timeStart", "long int")));
   }  // using namespace command
 }
 
@@ -96,7 +96,7 @@ Tracer::Tracer(const std::string n)
 /* --------------------------------------------------------------------- */
 /* --------------------------------------------------------------------- */
 
-void Tracer::addSignalToTrace(const SignalBase<int> &sig,
+void Tracer::addSignalToTrace(const SignalBase<sigtime_t> &sig,
                               const string &filename) {
   dgDEBUGIN(15);
   // openFile may throw so it should be called first.
@@ -112,7 +112,7 @@ void Tracer::addSignalToTraceByName(const string &signame,
                                     const string &filename) {
   dgDEBUGIN(15);
   istringstream iss(signame);
-  SignalBase<int> &sig = PoolStorage::getInstance()->getSignal(iss);
+  SignalBase<sigtime_t> &sig = PoolStorage::getInstance()->getSignal(iss);
   addSignalToTrace(sig, filename);
   dgDEBUGOUT(15);
 }
@@ -160,7 +160,7 @@ void Tracer::openFiles(const std::string &rootdir_,
   dgDEBUGOUT(15);
 }
 
-void Tracer::openFile(const SignalBase<int> &sig, const string &givenname) {
+void Tracer::openFile(const SignalBase<sigtime_t> &sig, const string &givenname) {
   dgDEBUGIN(15);
   string signame;
   if (givenname.length()) {
@@ -229,7 +229,7 @@ void Tracer::record() {
   dgDEBUGOUT(15);
 }
 
-void Tracer::recordSignal(std::ostream &os, const SignalBase<int> &sig) {
+void Tracer::recordSignal(std::ostream &os, const SignalBase<sigtime_t> &sig) {
   dgDEBUGIN(15);
 
   try {
@@ -247,7 +247,7 @@ void Tracer::recordSignal(std::ostream &os, const SignalBase<int> &sig) {
   dgDEBUGOUT(15);
 }
 
-int &Tracer::recordTrigger(int &dummy, const int &time) {
+sigtime_t &Tracer::recordTrigger(sigtime_t &dummy, const sigtime_t &time) {
   dgDEBUGIN(15) << "    time=" << time << endl;
   record();
   dgDEBUGOUT(15);
diff --git a/tests/debug-real-time-tracer.cpp b/tests/debug-real-time-tracer.cpp
index ace86839..c8a42d0e 100644
--- a/tests/debug-real-time-tracer.cpp
+++ b/tests/debug-real-time-tracer.cpp
@@ -28,9 +28,9 @@ namespace dynamicgraph {
 struct MyEntity : public dynamicgraph::Entity {
   static const std::string CLASS_NAME;
 
-  dynamicgraph::Signal<double, int> m_sigdSIN;
-  dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
-  dynamicgraph::SignalTimeDependent<double, int> m_sigdTwoTimeDepSOUT;
+  dynamicgraph::Signal<double, sigtime_t> m_sigdSIN;
+  dynamicgraph::SignalTimeDependent<double, sigtime_t> m_sigdTimeDepSOUT;
+  dynamicgraph::SignalTimeDependent<double, sigtime_t> m_sigdTwoTimeDepSOUT;
 
   explicit MyEntity(const std::string &name)
       : Entity(name),
@@ -46,7 +46,7 @@ struct MyEntity : public dynamicgraph::Entity {
     signalRegistration(m_sigdSIN << m_sigdTimeDepSOUT << m_sigdTwoTimeDepSOUT);
   }
 
-  double &update(double &res, const int &inTime) {
+  double &update(double &res, const sigtime_t &inTime) {
     const double &aDouble = m_sigdSIN(inTime);
     res = aDouble;
     return res;
@@ -83,11 +83,11 @@ BOOST_AUTO_TEST_CASE(test_tracer) {
   atracer.addSignalToTraceByName("my-entity.out_double", "output");
 
   /// Add trace by name
-  SignalBase<int> &out_double = entity.getSignal("out_double");
-  SignalBase<int> &out_double_2 = entity.getSignal("out2double");
+  SignalBase<sigtime_t> &out_double = entity.getSignal("out_double");
+  SignalBase<sigtime_t> &out_double_2 = entity.getSignal("out2double");
 
-  Signal<double, int> &in_double =
-      *(dynamic_cast<Signal<double, int> *>(&entity.getSignal("in_double")));
+  Signal<double, sigtime_t> &in_double =
+      *(dynamic_cast<Signal<double, sigtime_t> *>(&entity.getSignal("in_double")));
 
   in_double.setConstant(1.5);
   atracer.start();
@@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(test_tracer) {
   std::string emptybuf_cmd_str("empty");
   command::Command *acmd = atracer.getNewStyleCommand(emptybuf_cmd_str);
   acmd->execute();
-  for (int i = 0; i < 1000; i++) {
+  for (sigtime_t i = 0; i < 1000; i++) {
     in_double.setTime(i);
     out_double.recompute(i);
     out_double_2.recompute(i);
diff --git a/tests/debug-tracer.cpp b/tests/debug-tracer.cpp
index 0cd87f71..bab97fbb 100644
--- a/tests/debug-tracer.cpp
+++ b/tests/debug-tracer.cpp
@@ -27,10 +27,10 @@ namespace dynamicgraph {
 struct MyEntity : public dynamicgraph::Entity {
   static const std::string CLASS_NAME;
 
-  dynamicgraph::Signal<double, int> m_sigdSIN;
-  dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
-  dynamicgraph::SignalTimeDependent<Vector, int> m_sigVTimeDepSOUT;
-  dynamicgraph::SignalTimeDependent<double, int> m_sigdTwoTimeDepSOUT;
+  dynamicgraph::Signal<double, sigtime_t> m_sigdSIN;
+  dynamicgraph::SignalTimeDependent<double, sigtime_t> m_sigdTimeDepSOUT;
+  dynamicgraph::SignalTimeDependent<Vector, sigtime_t> m_sigVTimeDepSOUT;
+  dynamicgraph::SignalTimeDependent<double, sigtime_t> m_sigdTwoTimeDepSOUT;
 
   explicit MyEntity(const std::string &name)
       : Entity(name),
@@ -56,13 +56,13 @@ struct MyEntity : public dynamicgraph::Entity {
 
   virtual const std::string &getClassName() const { return CLASS_NAME; }
 
-  double &update(double &res, const int &inTime) {
+  double &update(double &res, const sigtime_t &inTime) {
     const double &aDouble = m_sigdSIN(inTime);
     res = aDouble;
     return res;
   }
 
-  Vector &updateVector(Vector &res, const int &inTime) {
+  Vector &updateVector(Vector &res, const sigtime_t &inTime) {
     const double &aDouble = m_sigdSIN(inTime);
     res.resize(2);
     res << aDouble, 2 * aDouble;
@@ -72,6 +72,8 @@ struct MyEntity : public dynamicgraph::Entity {
 DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(MyEntity, "MyEntity");
 }  // namespace dynamicgraph
 
+typedef dynamicgraph::sigtime_t sigtime_t;
+
 BOOST_AUTO_TEST_CASE(test_tracer) {
   using dynamicgraph::Vector;
 
@@ -96,14 +98,14 @@ BOOST_AUTO_TEST_CASE(test_tracer) {
   /// Add trace by name
   atracer.addSignalToTraceByName("my-entity.out_vector", "output-vector");
 
-  dynamicgraph::SignalBase<int> &aSignal = entity.getSignal("out2double");
+  dynamicgraph::SignalBase<sigtime_t> &aSignal = entity.getSignal("out2double");
 
-  dynamicgraph::Signal<double, int> &aSignalInt =
-      *(dynamic_cast<dynamicgraph::Signal<double, int> *>(
+  dynamicgraph::Signal<double, sigtime_t> &aSignalInt =
+      *(dynamic_cast<dynamicgraph::Signal<double, sigtime_t> *>(
           &entity.getSignal("in_double")));
 
-  dynamicgraph::Signal<Vector, int> &aSignalVector =
-      *(dynamic_cast<dynamicgraph::Signal<Vector, int> *>(
+  dynamicgraph::Signal<Vector, sigtime_t> &aSignalVector =
+      *(dynamic_cast<dynamicgraph::Signal<Vector, sigtime_t> *>(
           &entity.getSignal("out_vector")));
 
   /// Add trace by signal object
@@ -113,7 +115,7 @@ BOOST_AUTO_TEST_CASE(test_tracer) {
 
   atracer.start();
 
-  for (int i = 0; i < 1000; i++) {
+  for (sigtime_t i = 0; i < 1000; i++) {
     aSignal.setTime(i);
     aSignalInt.access(i);
     aSignalInt.setTime(i);
diff --git a/tests/entity.cpp b/tests/entity.cpp
index 3ae1e857..9851f742 100644
--- a/tests/entity.cpp
+++ b/tests/entity.cpp
@@ -32,8 +32,8 @@ using boost::test_tools::output_test_stream;
 namespace dynamicgraph {
 class CustomEntity : public Entity {
  public:
-  dynamicgraph::SignalPtr<double, int> m_sigdSIN, m_sigdSIN2;
-  dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
+  dynamicgraph::SignalPtr<double, sigtime_t> m_sigdSIN, m_sigdSIN2;
+  dynamicgraph::SignalTimeDependent<double, sigtime_t> m_sigdTimeDepSOUT;
 
   static const std::string CLASS_NAME;
   virtual const std::string &getClassName() const { return CLASS_NAME; }
@@ -65,7 +65,7 @@ class CustomEntity : public Entity {
     signalDeregistration("out_double");
   }
 
-  double &update(double &res, const int &inTime) {
+  double &update(double &res, const sigtime_t &inTime) {
     const double &aDouble = m_sigdSIN(inTime);
     res = aDouble;
     return res;
@@ -244,12 +244,13 @@ BOOST_AUTO_TEST_CASE(sendMsg) {
 }
 
 // WTF?
+typedef dynamicgraph::sigtime_t sigtime_t;
 BOOST_AUTO_TEST_CASE(wtf) {
   dynamicgraph::Entity &entity =
       dynamicgraph::PoolStorage::getInstance()->getEntity("my-entity");
 
   BOOST_CHECK_EQUAL(entity.test(),
-                    static_cast<dynamicgraph::SignalBase<int> *>(0));
+                    static_cast<dynamicgraph::SignalBase<sigtime_t> *>(0));
 
-  entity.test2(static_cast<dynamicgraph::SignalBase<int> *>(0));
+  entity.test2(static_cast<dynamicgraph::SignalBase<sigtime_t> *>(0));
 }
diff --git a/tests/pool.cpp b/tests/pool.cpp
index 2152c15a..66e0c105 100644
--- a/tests/pool.cpp
+++ b/tests/pool.cpp
@@ -21,12 +21,13 @@
 #include <boost/test/unit_test.hpp>
 
 using boost::test_tools::output_test_stream;
+typedef dynamicgraph::sigtime_t sigtime_t;
 
 struct MyEntity : public dynamicgraph::Entity {
   static const std::string CLASS_NAME;
 
-  dynamicgraph::SignalPtr<double, int> m_sigdSIN;
-  dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
+  dynamicgraph::SignalPtr<double, sigtime_t> m_sigdSIN;
+  dynamicgraph::SignalTimeDependent<double, sigtime_t> m_sigdTimeDepSOUT;
 
   explicit MyEntity(const std::string &name)
       : Entity(name),
@@ -43,7 +44,7 @@ struct MyEntity : public dynamicgraph::Entity {
 
   virtual const std::string &getClassName() const { return CLASS_NAME; }
 
-  double &update(double &res, const int &inTime) {
+  double &update(double &res, const sigtime_t &inTime) {
     const double &aDouble = m_sigdSIN(inTime);
     res = aDouble;
     return res;
@@ -158,7 +159,7 @@ BOOST_AUTO_TEST_CASE(pool_display) {
   /// Test name of a valid signal.
   std::istringstream an_iss("MyEntityInst.in_double");
 
-  dg::SignalBase<int> &aSignal =
+  dg::SignalBase<sigtime_t> &aSignal =
       dg::PoolStorage::getInstance()->getSignal(an_iss);
 
   std::string aSignalName = aSignal.getName();

From 1ffe19b9403cb383a4a1822fe5a4af0f3d49dbef Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent.lamiraux@laas.fr>
Date: Thu, 15 Jun 2023 16:07:58 +0200
Subject: [PATCH 2/8] [Value] Use int64_t, int32_t, uint64_t, uint32_t instead
 of

  int, long int, unsigned int, unsigned long int.
---
 include/dynamic-graph/value.h | 24 ++++++++--------
 src/command/value.cpp         | 52 +++++++++++++++++++----------------
 2 files changed, 40 insertions(+), 36 deletions(-)

diff --git a/include/dynamic-graph/value.h b/include/dynamic-graph/value.h
index 8890a2d6..f646c711 100644
--- a/include/dynamic-graph/value.h
+++ b/include/dynamic-graph/value.h
@@ -26,10 +26,10 @@ class DYNAMIC_GRAPH_DLLAPI EitherType {
   EitherType(const Value &value);
   ~EitherType();
   operator bool() const;
-  operator unsigned() const;
-  operator unsigned long int() const;
-  operator int() const;
-  operator long int() const;
+  operator uint32_t() const;
+  operator uint64_t() const;
+  operator int32_t() const;
+  operator int64_t() const;
   operator float() const;
   operator double() const;
   operator std::string() const;
@@ -68,10 +68,10 @@ class DYNAMIC_GRAPH_DLLAPI Value {
   ~Value();
   void deleteValue();
   explicit Value(const bool &value);
-  explicit Value(const unsigned &value);
-  explicit Value(const unsigned long int &value);
-  explicit Value(const int &value);
-  explicit Value(const long int &value);
+  explicit Value(const uint32_t &value);
+  explicit Value(const uint64_t &value);
+  explicit Value(const int32_t &value);
+  explicit Value(const int64_t &value);
   explicit Value(const float &value);
   explicit Value(const double &value);
   explicit Value(const std::string &value);
@@ -112,10 +112,10 @@ class DYNAMIC_GRAPH_DLLAPI Value {
  public:
   friend class EitherType;
   bool boolValue() const;
-  unsigned unsignedValue() const;
-  unsigned long int unsignedlongintValue() const;
-  int intValue() const;
-  long int longintValue() const;
+  uint32_t unsignedValue() const;
+  uint64_t unsignedlongintValue() const;
+  int32_t intValue() const;
+  int64_t longintValue() const;
   float floatValue() const;
   double doubleValue() const;
   std::string stringValue() const;
diff --git a/src/command/value.cpp b/src/command/value.cpp
index 457f852c..0641d266 100644
--- a/src/command/value.cpp
+++ b/src/command/value.cpp
@@ -21,12 +21,12 @@ EitherType::~EitherType() {
 }
 
 EitherType::operator bool() const { return value_->boolValue(); }
-EitherType::operator unsigned() const { return value_->unsignedValue(); }
-EitherType::operator unsigned long int() const {
+EitherType::operator uint32_t() const { return value_->unsignedValue(); }
+EitherType::operator uint64_t() const {
   return value_->unsignedlongintValue();
 }
-EitherType::operator int() const { return value_->intValue(); }
-EitherType::operator long int() const { return value_->longintValue(); }
+EitherType::operator int32_t() const { return value_->intValue(); }
+EitherType::operator int64_t() const { return value_->longintValue(); }
 EitherType::operator float() const { return value_->floatValue(); }
 EitherType::operator double() const { return value_->doubleValue(); }
 EitherType::operator std::string() const { return value_->stringValue(); }
@@ -42,16 +42,16 @@ void Value::deleteValue() {
       delete (const bool *)value_;
       break;
     case UNSIGNED:
-      delete (const unsigned *)value_;
+      delete (const uint32_t *)value_;
       break;
     case UNSIGNEDLONGINT:
-      delete (const unsigned long int *)value_;
+      delete (const uint64_t *)value_;
       break;
     case INT:
-      delete (const int *)value_;
+      delete (const int32_t *)value_;
       break;
     case LONGINT:
-      delete (const long int *)value_;
+      delete (const int64_t *)value_;
       break;
     case FLOAT:
       delete (const float *)value_;
@@ -85,11 +85,13 @@ void Value::deleteValue() {
 Value::~Value() { deleteValue(); }
 
 Value::Value(const bool &value) : type_(BOOL), value_(new bool(value)) {}
-Value::Value(const unsigned &value)
-    : type_(UNSIGNED), value_(new unsigned(value)) {}
-Value::Value(const unsigned long int &value)
-    : type_(UNSIGNEDLONGINT), value_(new unsigned long int(value)) {}
-Value::Value(const int &value) : type_(INT), value_(new int(value)) {}
+Value::Value(const uint32_t &value)
+    : type_(UNSIGNED), value_(new uint32_t(value)) {}
+Value::Value(const uint64_t &value)
+    : type_(UNSIGNEDLONGINT), value_(new uint64_t(value)) {}
+Value::Value(const int32_t &value) : type_(INT), value_(new int32_t(value)) {}
+Value::Value(const int64_t &value) : type_(LONGINT), value_(new int64_t(value))
+{}
 Value::Value(const float &value) : type_(FLOAT), value_(new float(value)) {}
 Value::Value(const double &value) : type_(DOUBLE), value_(new double(value)) {}
 Value::Value(const std::string &value)
@@ -206,25 +208,25 @@ bool Value::boolValue() const {
   throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an bool");
 }
 
-unsigned Value::unsignedValue() const {
-  if (type_ == UNSIGNED) return *((const unsigned *)value_);
+uint32_t Value::unsignedValue() const {
+  if (type_ == UNSIGNED) return *((const uint32_t *)value_);
   throw ExceptionAbstract(ExceptionAbstract::TOOLS,
                           "value is not an unsigned int");
 }
 
-unsigned long int Value::unsignedlongintValue() const {
-  if (type_ == UNSIGNEDLONGINT) return *((const unsigned long int *)value_);
+uint64_t Value::unsignedlongintValue() const {
+  if (type_ == UNSIGNEDLONGINT) return *((const uint64_t *)value_);
   throw ExceptionAbstract(ExceptionAbstract::TOOLS,
                           "value is not an unsigned long int");
 }
 
-long int Value::longintValue() const {
-  if (type_ == LONGINT) return *((const long int *)value_);
+int64_t Value::longintValue() const {
+  if (type_ == LONGINT) return *((const int64_t *)value_);
   throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an long int");
 }
 
-int Value::intValue() const {
-  if (type_ == INT) return *((const int *)value_);
+int32_t Value::intValue() const {
+  if (type_ == INT) return *((const int32_t *)value_);
   throw ExceptionAbstract(ExceptionAbstract::TOOLS, "value is not an int");
 }
 
@@ -356,12 +358,14 @@ std::ostream &operator<<(std::ostream &os, const Value &value) {
 template <>
 const Value::Type ValueHelper<bool>::TypeID = Value::BOOL;
 template <>
-const Value::Type ValueHelper<unsigned>::TypeID = Value::UNSIGNED;
+const Value::Type ValueHelper<uint32_t>::TypeID = Value::UNSIGNED;
 template <>
-const Value::Type ValueHelper<unsigned long int>::TypeID =
+const Value::Type ValueHelper<uint64_t>::TypeID =
     Value::UNSIGNEDLONGINT;
 template <>
-const Value::Type ValueHelper<int>::TypeID = Value::INT;
+const Value::Type ValueHelper<int32_t>::TypeID = Value::INT;
+template <>
+const Value::Type ValueHelper<int64_t>::TypeID = Value::LONGINT;
 template <>
 const Value::Type ValueHelper<float>::TypeID = Value::FLOAT;
 template <>

From 0b2fbe5c2824c8ea8749ca609e8bb8e4ca1b6a5b Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent@laas.fr>
Date: Fri, 16 Jun 2023 09:09:46 +0200
Subject: [PATCH 3/8] Use int64_t for signal time.

---
 include/dynamic-graph/fwd.hh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/dynamic-graph/fwd.hh b/include/dynamic-graph/fwd.hh
index e7541020..cabbf5f8 100644
--- a/include/dynamic-graph/fwd.hh
+++ b/include/dynamic-graph/fwd.hh
@@ -9,7 +9,7 @@
 
 namespace dynamicgraph {
 // Set a typedef for signal time type
-typedef int sigtime_t;
+typedef int64_t sigtime_t;
 
 // to be replace by std:: when we switch to C++11 and later
 using boost::const_pointer_cast;

From 6f8cc21d842e3463dd1d27d50ec38c7ee5c3140a Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent.lamiraux@laas.fr>
Date: Wed, 21 Jun 2023 10:49:26 +0200
Subject: [PATCH 4/8] [Command] Implement setter command for int64_t.

---
 include/dynamic-graph/command-setter.t.cpp | 34 ++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/include/dynamic-graph/command-setter.t.cpp b/include/dynamic-graph/command-setter.t.cpp
index f01e2fe2..fa918803 100644
--- a/include/dynamic-graph/command-setter.t.cpp
+++ b/include/dynamic-graph/command-setter.t.cpp
@@ -120,6 +120,40 @@ Value Setter<E, int>::doExecute() {
   return Value();
 }
 
+//
+// Template specialization: int64_t
+//
+template <class E>
+class Setter<E, int64_t> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type int64_t
+  typedef void (E::*SetterMethod)(const int64_t &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, int64_t>::Setter(E &entity, SetterMethod setterMethod,
+                       const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::LONGINT), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, int64_t>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  int64_t value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
 //
 // Template specialization: float
 //

From 3f6e4f173ac1c1e7dfe57c4800aa1cfea201955d Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent.lamiraux@laas.fr>
Date: Wed, 21 Jun 2023 10:49:26 +0200
Subject: [PATCH 5/8] [Command] Implement setter command for uint64_t.

---
 include/dynamic-graph/command-setter.t.cpp | 35 ++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/include/dynamic-graph/command-setter.t.cpp b/include/dynamic-graph/command-setter.t.cpp
index fa918803..159b6411 100644
--- a/include/dynamic-graph/command-setter.t.cpp
+++ b/include/dynamic-graph/command-setter.t.cpp
@@ -86,6 +86,41 @@ Value Setter<E, unsigned>::doExecute() {
   return Value();
 }
 
+//
+// Template specialization: unsigned long
+//
+template <class E>
+class Setter<E, unsigned long> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type unsigned long
+  typedef void (E::*SetterMethod)(const unsigned long &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, unsigned long>::Setter(E &entity, SetterMethod setterMethod,
+                            const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::UNSIGNEDLONGINT),
+              docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, unsigned long>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  unsigned long value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
 //
 // Template specialization: int
 //

From f3559dd7166bf8e3ef02d57ac5bd64cff9cc1ee1 Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent@laas.fr>
Date: Thu, 22 Jun 2023 16:57:51 +0200
Subject: [PATCH 6/8] Add typedef size_type as long int.

---
 include/dynamic-graph/linear-algebra.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/dynamic-graph/linear-algebra.h b/include/dynamic-graph/linear-algebra.h
index c600ff17..84fbe456 100644
--- a/include/dynamic-graph/linear-algebra.h
+++ b/include/dynamic-graph/linear-algebra.h
@@ -12,6 +12,7 @@
 namespace dynamicgraph {
 typedef Eigen::MatrixXd Matrix;
 typedef Eigen::VectorXd Vector;
+typedef Matrix::Index size_type;
 }  // namespace dynamicgraph
 
 #endif  // DYNAMIC_GRAPH_LINEAR_ALGEBRA_H

From 233e76db8d36f9bdbb025920f0aa3ba2da5f5bb6 Mon Sep 17 00:00:00 2001
From: Florent Lamiraux <florent@laas.fr>
Date: Thu, 22 Jun 2023 16:58:12 +0200
Subject: [PATCH 7/8] [SignalPtr] Simplify and clean up

  - it is not possible any more to plug a signal of type B into
    a SignalPtr of type A when B derives from A. This feature was anyway
    not used anymore.
---
 include/dynamic-graph/signal-base.h    | 10 ---
 include/dynamic-graph/signal-ptr.h     |  7 --
 include/dynamic-graph/signal-ptr.t.cpp | 91 ++++----------------------
 include/dynamic-graph/signal.h         |  5 --
 tests/signal-all.cpp                   |  7 --
 tests/signal-ptr.cpp                   | 70 --------------------
 tests/signal-time-dependent.cpp        |  9 ---
 7 files changed, 11 insertions(+), 188 deletions(-)

diff --git a/include/dynamic-graph/signal-base.h b/include/dynamic-graph/signal-base.h
index a260a8ea..3bc76290 100644
--- a/include/dynamic-graph/signal-base.h
+++ b/include/dynamic-graph/signal-base.h
@@ -186,16 +186,6 @@ class SignalBase : public boost::noncopyable {
 
   /// \}
 
-  /// \name Test
-  /// \{
-  virtual void checkCompatibility() {
-    DG_THROW ExceptionSignal(ExceptionSignal::PLUG_IMPOSSIBLE,
-                             "Abstract signal not compatible with anything.",
-                             "(while trying to plug <%s>).",
-                             this->getName().c_str());
-  }
-  /// \}
-
  protected:
   std::string name;
   Time signalTime;
diff --git a/include/dynamic-graph/signal-ptr.h b/include/dynamic-graph/signal-ptr.h
index 78d13313..50ceb4b3 100644
--- a/include/dynamic-graph/signal-ptr.h
+++ b/include/dynamic-graph/signal-ptr.h
@@ -31,7 +31,6 @@ class SignalPtr : public virtual Signal<T, Time> {
  protected:
   Signal<T, Time> *signalPtr;
   bool modeNoThrow;
-  bool transmitAbstract;
   SignalBase<Time> *abstractTransmitter;
   T *transmitAbstractData;
 
@@ -42,7 +41,6 @@ class SignalPtr : public virtual Signal<T, Time> {
       : Signal<T, Time>(name),
         signalPtr(ptr),
         modeNoThrow(false),
-        transmitAbstract(false),
         abstractTransmitter(NULL) {}
 
   virtual ~SignalPtr() { signalPtr = NULL; }
@@ -51,15 +49,12 @@ class SignalPtr : public virtual Signal<T, Time> {
   /* --- PLUG-IN OPERATION --- */
   Signal<T, Time> *getPtr();                       // throw
   const Signal<T, Time> *getPtr() const;           // throw
-  SignalBase<Time> *getAbstractPtr();              // throw
-  const SignalBase<Time> *getAbstractPtr() const;  // throw
   virtual void plug(SignalBase<Time> *ref);
 
   virtual void unplug() { plug(NULL); }
 
   virtual bool isPlugged() const { return (NULL != signalPtr); }
   virtual SignalBase<Time> *getPluged() const { return signalPtr; }
-  virtual bool isAbstractPluged() const;
   virtual const Time &getTime() const;
 
   /* Equivalent operator-like definitions. */
@@ -91,8 +86,6 @@ class SignalPtr : public virtual Signal<T, Time> {
   virtual inline void setConstantDefault() { setConstantDefault(accessCopy()); }
   inline void unsetConstantDefault() { modeNoThrow = false; }
 
-  virtual void checkCompatibility();
-
  public: /* --- INHERITANCE --- */
   /* SignalPtr could be used as a classical signal, through the normal
    * setting functions. The behavior is to plugged the signalPtr on
diff --git a/include/dynamic-graph/signal-ptr.t.cpp b/include/dynamic-graph/signal-ptr.t.cpp
index ed7a4b33..dec56955 100644
--- a/include/dynamic-graph/signal-ptr.t.cpp
+++ b/include/dynamic-graph/signal-ptr.t.cpp
@@ -12,11 +12,6 @@
 #include <dynamic-graph/debug.h>
 
 namespace dynamicgraph {
-template <class T, class Time>
-bool SignalPtr<T, Time>::isAbstractPluged() const {
-  return ((NULL != signalPtr) || (abstractTransmitter));
-}
-
 template <class T, class Time>
 Signal<T, Time> *SignalPtr<T, Time>::getPtr() {
   dgTDEBUGIN(25);
@@ -42,38 +37,11 @@ const Signal<T, Time> *SignalPtr<T, Time>::getPtr() const {
   return signalPtr;
 }
 
-template <class T, class Time>
-SignalBase<Time> *SignalPtr<T, Time>::getAbstractPtr() {
-  if (!isAbstractPluged()) {
-    DG_THROW ExceptionSignal(ExceptionSignal::NOT_INITIALIZED,
-                             "In SignalPtr: SIN ptr not set.",
-                             " (in signal <%s>)", getName().c_str());
-  }
-  if (NULL != signalPtr)
-    return signalPtr;
-  else
-    return abstractTransmitter;
-}
-
-template <class T, class Time>
-const SignalBase<Time> *SignalPtr<T, Time>::getAbstractPtr() const {
-  if (!isAbstractPluged()) {
-    DG_THROW ExceptionSignal(ExceptionSignal::NOT_INITIALIZED,
-                             "In SignalPtr: SIN ptr not set.",
-                             " (in signal <%s>)", getName().c_str());
-  }
-  if (NULL != signalPtr)
-    return signalPtr;
-  else
-    return abstractTransmitter;
-}
-
 template <class T, class Time>
 void SignalPtr<T, Time>::plug(SignalBase<Time> *unknown_ref) {
   dgTDEBUGIN(5);
   if (!unknown_ref) {
     signalPtr = NULL;
-    transmitAbstract = false;
     dgTDEBUGOUT(5);
     return;
   }
@@ -82,56 +50,25 @@ void SignalPtr<T, Time>::plug(SignalBase<Time> *unknown_ref) {
               << typeid(Signal<T, Time>::Tcopy1).name() << "{ " << std::endl;
 
   Signal<T, Time> *ref = dynamic_cast<Signal<T, Time> *>(unknown_ref);
-  if (NULL == ref) {
-    try {
-      unknown_ref->checkCompatibility();
-    } catch (T *t) {
-      dgTDEBUG(25) << "Cast THROW ok." << std::endl;
-      Signal<T, Time>::setReference(t);
-      transmitAbstract = true;
-      abstractTransmitter = unknown_ref;
-      transmitAbstractData = t;
-    } catch (...) {
-      dgTDEBUG(25) << "Fatal error." << std::endl;
-      transmitAbstract = false;
-      DG_THROW ExceptionSignal(ExceptionSignal::PLUG_IMPOSSIBLE,
-                               "Compl. Uncompatible types for plugin.",
-                               "(while trying to plug <%s> on <%s>)"
-                               " with types <%s> on <%s>.",
-                               unknown_ref->getName().c_str(),
-                               this->getName().c_str(), typeid(T).name(),
-                               typeid(unknown_ref).name());
-    }
-  } else {
+  if (NULL != ref) {
     dgTDEBUG(25) << "Cast ok." << std::endl;
-    transmitAbstract = false;
     signalPtr = ref;
   }
   dgTDEBUGOUT(5);
 }
 
-template <class T, class Time>
-void SignalPtr<T, Time>::checkCompatibility() {
-  if (isPlugged() && (!autoref())) {
-    getPtr()->checkCompatibility();
-  } else if (isAbstractPluged() && (!autoref())) {
-    abstractTransmitter->checkCompatibility();
-  } else
-    Signal<T, Time>::checkCompatibility();
-}
-
 template <class T, class Time>
 bool SignalPtr<T, Time>::needUpdate(const Time &t) const {
-  if ((isAbstractPluged()) && (!autoref())) {
-    return getAbstractPtr()->needUpdate(t);
+  if ((isPlugged()) && (!autoref())) {
+    return getPtr()->needUpdate(t);
   } else
     return Signal<T, Time>::needUpdate(t);
 }
 
 template <class T, class Time>
 const Time &SignalPtr<T, Time>::getTime() const {
-  if ((isAbstractPluged()) && (!autoref())) {
-    return getAbstractPtr()->getTime();
+  if ((isPlugged()) && (!autoref())) {
+    return getPtr()->getTime();
   }
   return Signal<T, Time>::getTime();
 }
@@ -150,10 +87,6 @@ const T &SignalPtr<T, Time>::access(const Time &t) {
   } else if (autoref()) {
     dgTDEBUGOUT(15);
     return Signal<T, Time>::access(t);
-  } else if (transmitAbstract) {
-    abstractTransmitter->recompute(t);
-    dgTDEBUGOUT(15);
-    return *transmitAbstractData;
   } else {
     dgTDEBUGOUT(15);
     return getPtr()->access(t);
@@ -166,8 +99,6 @@ const T &SignalPtr<T, Time>::accessCopy() const {
     return Signal<T, Time>::accessCopy();
   else if (autoref())
     return Signal<T, Time>::accessCopy();
-  else if (transmitAbstract)
-    return *transmitAbstractData;
   else
     return getPtr()->accessCopy();
 }
@@ -176,9 +107,9 @@ std::ostream &SignalPtr<T, Time>::writeGraph(std::ostream &os) const {
   std::string LeaderLocalName;
   std::string LeaderNodeName;
   Signal<T, Time>::ExtractNodeAndLocalNames(LeaderLocalName, LeaderNodeName);
-  if (isAbstractPluged() && !autoref()) {
+  if (isPlugged() && !autoref()) {
     std::string itLocalName, itNodeName;
-    getAbstractPtr()->ExtractNodeAndLocalNames(itLocalName, itNodeName);
+    getPtr()->ExtractNodeAndLocalNames(itLocalName, itNodeName);
     os << "\t\"" << itNodeName << "\" -> \"" << LeaderNodeName << "\""
        << std::endl
        << "\t [ headlabel = \"" << LeaderLocalName << "\" , taillabel = \""
@@ -193,10 +124,10 @@ std::ostream &SignalPtr<T, Time>::display(std::ostream &os) const {
                  << "||" << signalPtr;
   { Signal<T, Time>::display(os); }
 
-  if ((isAbstractPluged()) && (!autoref())) {
+  if ((isPlugged()) && (!autoref())) {
     os << " -->-- PLUGGED";
   } else {
-    if (!isAbstractPluged())
+    if (!isPlugged())
       os << " UNPLUGGED";
     else if (autoref())
       os << " AUTOPLUGGED";
@@ -213,8 +144,8 @@ std::ostream &SignalPtr<T, Time>::displayDependencies(std::ostream &os,
                                                       std::string next1,
                                                       std::string next2) const {
   dgTDEBUGIN(25);
-  if ((isAbstractPluged()) && (!autoref())) {
-    getAbstractPtr()->displayDependencies(
+  if ((isPlugged()) && (!autoref())) {
+    getPtr()->displayDependencies(
         os, depth, space, next1 + "-- " + SignalBase<Time>::name + " -->",
         next2);
   } else {
diff --git a/include/dynamic-graph/signal.h b/include/dynamic-graph/signal.h
index ee11c738..60d3a544 100644
--- a/include/dynamic-graph/signal.h
+++ b/include/dynamic-graph/signal.h
@@ -106,11 +106,6 @@ class Signal : public SignalBase<Time> {
     aClassName = typeid(this).name();
   }
 
- public:
-  /// checkCompatibility is used to get the object contained in the
-  /// signal. This used to verify if a dynamic cast is possible or not.
-  virtual void checkCompatibility() { throw Tcopy; }
-
  private:
   const T &setTcopy(const T &t);
   T &getTwork();
diff --git a/tests/signal-all.cpp b/tests/signal-all.cpp
index 7235dfdb..13be0ffe 100644
--- a/tests/signal-all.cpp
+++ b/tests/signal-all.cpp
@@ -90,13 +90,6 @@ BOOST_AUTO_TEST_CASE(test_base) {
   }
   BOOST_CHECK(res);
 
-  res = false;
-  try {
-    /// Check signal compatibility.
-    sigB.checkCompatibility();
-  } catch (const ExceptionSignal &aea) {
-    res = (aea.getCode() == ExceptionSignal::PLUG_IMPOSSIBLE);
-  }
   /// Verify set command value
 
   /// set
diff --git a/tests/signal-ptr.cpp b/tests/signal-ptr.cpp
index 39b324a0..ec6e01d1 100644
--- a/tests/signal-ptr.cpp
+++ b/tests/signal-ptr.cpp
@@ -116,29 +116,6 @@ BOOST_AUTO_TEST_CASE(normal_cst_test) {
   output_test_stream output;
   sigNotPlug.display(output);
   cstSigNotPlug.display(output);
-
-  /// Testing getAbsatractPtr() interface: no plug
-  res = false;
-  try {
-    sigNotPlug.getAbstractPtr();
-  } catch (const ExceptionSignal &aea) {
-    res = (aea.getCode() == ExceptionSignal::NOT_INITIALIZED);
-  }
-  BOOST_CHECK(res);
-
-  /// Testing const getAbstractPtr() interface: no plug case
-  try {
-    cstSigNotPlug.getAbstractPtr();
-  } catch (const ExceptionSignal &aea) {
-    res = (aea.getCode() == ExceptionSignal::NOT_INITIALIZED);
-  }
-  BOOST_CHECK(res);
-
-  try {
-    sigNotPlug.checkCompatibility();
-  } catch (...) {
-  }
-  BOOST_CHECK(res);
 }
 
 BOOST_AUTO_TEST_CASE(normal_test) {
@@ -171,33 +148,10 @@ BOOST_AUTO_TEST_CASE(normal_test) {
   sigPtrARef.plug(0);
   sigPtrARef.plug(&sigRef);
   sigPtrBRef.plug(&sigPtrARef);
-  /// Try to plug an incompatible signal.
-  /// leave
-  bool res = false;
-  try {
-    sigPtrARef.plug(&sigstr);
-  } catch (const ExceptionSignal &aes) {
-    res = (aes.getCode() == ExceptionSignal::PLUG_IMPOSSIBLE);
-  }
-  BOOST_CHECK(res);
-
   /// Plug the signal.
   sigPtrAbstractRef.plug(&sigRef);
   sigPtrA.getPtr();
   BOOST_CHECK(true);
-  try {
-    sigPtrARef.checkCompatibility();
-  } catch (const ExceptionSignal &aes) {
-    /// Should be NOT_INITIALIZED becase the last plug
-    /// on sigstr failed.
-    res = (aes.getCode() == ExceptionSignal::NOT_INITIALIZED);
-  } catch (const std::exception &e) {
-    std::cout << "Standard Exception:" << e.what() << std::endl;
-  } catch (...) {
-    std::cout << "Anything else: " << std::endl;
-  }
-  sigPtrA.needUpdate(5);
-  BOOST_CHECK(true);
 
   int ltime = sigPtrA.getTime();
   sigPtrA.getPluged();
@@ -205,29 +159,6 @@ BOOST_AUTO_TEST_CASE(normal_test) {
   BOOST_CHECK(true);
 
   sigPtrB.getPtr();
-  /// Test sigPtrAbstract with a normal plug.
-  res = false;
-  try {
-    sigPtrAbstract.getAbstractPtr();
-  } catch (ExceptionSignal &aes) {
-    /// Should be NOT_INITIALIZED becase the last plug
-    /// on sigstr failed.
-    std::cout << "Code: " << aes.getCode() << std::endl;
-    res = (aes.getCode() == ExceptionSignal::NOT_INITIALIZED);
-  } catch (...) {
-    std::cout << "Anything else with sigPtrAbstract.getAbstractPtr()"
-              << std::endl;
-  }
-  BOOST_CHECK(true);
-
-  /// Test the case where the plug ref is zero.
-  sigPtrAbstractRef.plug(0);
-  BOOST_CHECK(true);
-
-  assert(sigRef.isPlugged() != true);
-  SignalBase<int> *t = sigRef.getPluged();
-  // assert(sigPtrA.get()=false);
-
   // TODO Can't check if the constant change
   sigPtrA.setConstantDefault(1.2);
   // getconstant
@@ -251,7 +182,6 @@ BOOST_AUTO_TEST_CASE(normal_test) {
   // getconstant
   sigPtrA.displayDependencies(output);
 
-  cout << t << std::endl;
   cout << "Sig = ";
   sigRef.get(cout);
   cout << std::endl;
diff --git a/tests/signal-time-dependent.cpp b/tests/signal-time-dependent.cpp
index 0cd4ead9..227ab530 100644
--- a/tests/signal-time-dependent.cpp
+++ b/tests/signal-time-dependent.cpp
@@ -228,13 +228,4 @@ BOOST_AUTO_TEST_CASE(signaltimedependent) {
   const double &avalue = sig1(6);
   output << avalue;
   BOOST_CHECK(true);
-  /// Verify check compatibility
-  try {
-    sig1.checkCompatibility();
-  }
-  //  catch(double e)
-  catch (...) {
-    std::cout << "Message: test \n";
-  }
-  BOOST_CHECK(true);
 }

From 793221c5cf23b1c7309543f9bb1b70ecd34e0337 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 23 Jun 2023 09:56:18 +0000
Subject: [PATCH 8/8] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 include/dynamic-graph/command-setter.t.cpp |  4 ++--
 include/dynamic-graph/signal-helper.h      | 26 ++++++++++++----------
 include/dynamic-graph/signal-ptr.h         |  4 ++--
 src/command/value.cpp                      | 11 ++++-----
 src/traces/tracer.cpp                      |  3 ++-
 tests/debug-real-time-tracer.cpp           |  3 ++-
 6 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/include/dynamic-graph/command-setter.t.cpp b/include/dynamic-graph/command-setter.t.cpp
index 159b6411..ea358dd7 100644
--- a/include/dynamic-graph/command-setter.t.cpp
+++ b/include/dynamic-graph/command-setter.t.cpp
@@ -106,7 +106,7 @@ class Setter<E, unsigned long> : public Command {
 
 template <class E>
 Setter<E, unsigned long>::Setter(E &entity, SetterMethod setterMethod,
-                            const std::string &docString)
+                                 const std::string &docString)
     : Command(entity, boost::assign::list_of(Value::UNSIGNEDLONGINT),
               docString),
       setterMethod_(setterMethod) {}
@@ -175,7 +175,7 @@ class Setter<E, int64_t> : public Command {
 
 template <class E>
 Setter<E, int64_t>::Setter(E &entity, SetterMethod setterMethod,
-                       const std::string &docString)
+                           const std::string &docString)
     : Command(entity, boost::assign::list_of(Value::LONGINT), docString),
       setterMethod_(setterMethod) {}
 
diff --git a/include/dynamic-graph/signal-helper.h b/include/dynamic-graph/signal-helper.h
index 2eb87b5f..443de435 100644
--- a/include/dynamic-graph/signal-helper.h
+++ b/include/dynamic-graph/signal-helper.h
@@ -41,16 +41,17 @@
 #define DECLARE_SIGNAL_OUT_FUNCTION(name, type) \
   type &SIGNAL_OUT_FUNCTION_NAME(name)(type &, sigtime_t)
 
-#define DEFINE_SIGNAL_OUT_FUNCTION(name, type) \
-  type &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name)(type & s, sigtime_t iter)
+#define DEFINE_SIGNAL_OUT_FUNCTION(name, type)                    \
+  type &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name)(type & s, \
+                                                        sigtime_t iter)
 
 #define SIGNAL_OUT_FUNCTION(name) name##SOUT_function
 
-#define DECLARE_SIGNAL_OUT(name, type)                           \
- public:                                                         \
+#define DECLARE_SIGNAL_OUT(name, type)                                 \
+ public:                                                               \
   ::dynamicgraph::SignalTimeDependent<type, sigtime_t> m_##name##SOUT; \
-                                                                 \
- protected:                                                      \
+                                                                       \
+ protected:                                                            \
   type &SIGNAL_OUT_FUNCTION(name)(type &, sigtime_t)
 
 #define CONSTRUCT_SIGNAL_OUT(name, type, dep)                                \
@@ -64,14 +65,15 @@
 #define DECLARE_SIGNAL_INNER_FUNCTION(name, type) \
   type &SIGNAL_INNER_FUNCTION_NAME(name)(type &, sigtime_t)
 
-#define DEFINE_SIGNAL_INNER_FUNCTION(name, type) \
-  type &EntityClassName::SIGNAL_INNER_FUNCTION_NAME(name)(type & s, sigtime_t iter)
+#define DEFINE_SIGNAL_INNER_FUNCTION(name, type)                    \
+  type &EntityClassName::SIGNAL_INNER_FUNCTION_NAME(name)(type & s, \
+                                                          sigtime_t iter)
 
-#define DECLARE_SIGNAL_INNER(name, type)                           \
- public:                                                           \
+#define DECLARE_SIGNAL_INNER(name, type)                                 \
+ public:                                                                 \
   ::dynamicgraph::SignalTimeDependent<type, sigtime_t> m_##name##SINNER; \
-                                                                   \
- protected:                                                        \
+                                                                         \
+ protected:                                                              \
   DECLARE_SIGNAL_INNER_FUNCTION(name, type)
 
 #define CONSTRUCT_SIGNAL_INNER(name, type, dep)                                \
diff --git a/include/dynamic-graph/signal-ptr.h b/include/dynamic-graph/signal-ptr.h
index 50ceb4b3..9f1b683f 100644
--- a/include/dynamic-graph/signal-ptr.h
+++ b/include/dynamic-graph/signal-ptr.h
@@ -47,8 +47,8 @@ class SignalPtr : public virtual Signal<T, Time> {
 
  public:
   /* --- PLUG-IN OPERATION --- */
-  Signal<T, Time> *getPtr();                       // throw
-  const Signal<T, Time> *getPtr() const;           // throw
+  Signal<T, Time> *getPtr();              // throw
+  const Signal<T, Time> *getPtr() const;  // throw
   virtual void plug(SignalBase<Time> *ref);
 
   virtual void unplug() { plug(NULL); }
diff --git a/src/command/value.cpp b/src/command/value.cpp
index 0641d266..371ade6c 100644
--- a/src/command/value.cpp
+++ b/src/command/value.cpp
@@ -22,9 +22,7 @@ EitherType::~EitherType() {
 
 EitherType::operator bool() const { return value_->boolValue(); }
 EitherType::operator uint32_t() const { return value_->unsignedValue(); }
-EitherType::operator uint64_t() const {
-  return value_->unsignedlongintValue();
-}
+EitherType::operator uint64_t() const { return value_->unsignedlongintValue(); }
 EitherType::operator int32_t() const { return value_->intValue(); }
 EitherType::operator int64_t() const { return value_->longintValue(); }
 EitherType::operator float() const { return value_->floatValue(); }
@@ -90,8 +88,8 @@ Value::Value(const uint32_t &value)
 Value::Value(const uint64_t &value)
     : type_(UNSIGNEDLONGINT), value_(new uint64_t(value)) {}
 Value::Value(const int32_t &value) : type_(INT), value_(new int32_t(value)) {}
-Value::Value(const int64_t &value) : type_(LONGINT), value_(new int64_t(value))
-{}
+Value::Value(const int64_t &value)
+    : type_(LONGINT), value_(new int64_t(value)) {}
 Value::Value(const float &value) : type_(FLOAT), value_(new float(value)) {}
 Value::Value(const double &value) : type_(DOUBLE), value_(new double(value)) {}
 Value::Value(const std::string &value)
@@ -360,8 +358,7 @@ const Value::Type ValueHelper<bool>::TypeID = Value::BOOL;
 template <>
 const Value::Type ValueHelper<uint32_t>::TypeID = Value::UNSIGNED;
 template <>
-const Value::Type ValueHelper<uint64_t>::TypeID =
-    Value::UNSIGNEDLONGINT;
+const Value::Type ValueHelper<uint64_t>::TypeID = Value::UNSIGNEDLONGINT;
 template <>
 const Value::Type ValueHelper<int32_t>::TypeID = Value::INT;
 template <>
diff --git a/src/traces/tracer.cpp b/src/traces/tracer.cpp
index 721b3214..90a74b5d 100644
--- a/src/traces/tracer.cpp
+++ b/src/traces/tracer.cpp
@@ -160,7 +160,8 @@ void Tracer::openFiles(const std::string &rootdir_,
   dgDEBUGOUT(15);
 }
 
-void Tracer::openFile(const SignalBase<sigtime_t> &sig, const string &givenname) {
+void Tracer::openFile(const SignalBase<sigtime_t> &sig,
+                      const string &givenname) {
   dgDEBUGIN(15);
   string signame;
   if (givenname.length()) {
diff --git a/tests/debug-real-time-tracer.cpp b/tests/debug-real-time-tracer.cpp
index c8a42d0e..92066072 100644
--- a/tests/debug-real-time-tracer.cpp
+++ b/tests/debug-real-time-tracer.cpp
@@ -87,7 +87,8 @@ BOOST_AUTO_TEST_CASE(test_tracer) {
   SignalBase<sigtime_t> &out_double_2 = entity.getSignal("out2double");
 
   Signal<double, sigtime_t> &in_double =
-      *(dynamic_cast<Signal<double, sigtime_t> *>(&entity.getSignal("in_double")));
+      *(dynamic_cast<Signal<double, sigtime_t> *>(
+          &entity.getSignal("in_double")));
 
   in_double.setConstant(1.5);
   atracer.start();