Define a specific type for signal time.

Author: Florent Lamiraux

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;

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;

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. */

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.
 

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)

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

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,

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 {

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,

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);
 }