Define a specific type for signal time.

Florent Lamiraux · florent-lamiraux · commit 9b21dae87faf · 2023-07-28T09:08:01.000+02:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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,27 +31,27 @@
 /**/
 
 #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)
 
 /**/
 
 #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
@@ -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
@@ -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,16 +81,16 @@ 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; }
   void stop() { play = false; }
 
  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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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,18 +85,18 @@ 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
 }
 
 /* --------------------------------------------------------------------- */
 /* --------------------------------------------------------------------- */
 /* --------------------------------------------------------------------- */
 
-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
diff --git a/tests/debug-tracer.cpp b/tests/debug-tracer.cpp
diff --git a/tests/entity.cpp b/tests/entity.cpp
diff --git a/tests/pool.cpp b/tests/pool.cpp

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ SignalArray<Time> operator<<(SignalBase<Time> &sig1, SignalBase<Time> &sig2) {`
`147`	`147`	`return res;`
`148`	`148`	`}`
`149`	`149`
`150`		`-DYNAMIC_GRAPH_DLLAPI extern SignalArray<int> sotNOSIGNAL;`
	`150`	`+DYNAMIC_GRAPH_DLLAPI extern SignalArray<sigtime_t> sotNOSIGNAL;`
`151`	`151`
`152`	`152`	`} // end of namespace dynamicgraph.`
`153`	`153`
Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,5 @@`
`10`	`10`	`#include <dynamic-graph/signal-array.h>`
`11`	`11`
`12`	`12`	`namespace dynamicgraph {`
`13`		`-SignalArray<int> sotNOSIGNAL(0);`
	`13`	`+SignalArray<sigtime_t> sotNOSIGNAL(0);`
`14`	`14`	`}`