include/dynamic-graph/exception-traces.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_EXCEPTION_TRACES_H
+#define DYNAMIC_GRAPH_EXCEPTION_TRACES_H
+#include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/exception-abstract.h>
+
+#include <dynamic-graph/fwd.hh>
+#include <string>
+
+namespace dynamicgraph {
+/// \ingroup error
+///
+/// \brief Exceptions raised when an error related to traces happen.
+class DYNAMIC_GRAPH_DLLAPI ExceptionTraces : public ExceptionAbstract {
+ public:
+  enum ErrorCodeEnum { GENERIC = ExceptionAbstract::TRACES, NOT_OPEN };
+
+  static const std::string EXCEPTION_NAME;
+
+  explicit ExceptionTraces(const ExceptionTraces::ErrorCodeEnum &errcode,
+                           const std::string &msg = "");
+  ExceptionTraces(const ExceptionTraces::ErrorCodeEnum &errcode,
+                  const std::string &msg, const char *format, ...);
+  virtual ~ExceptionTraces() throw() {}
+
+  virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }
+};
+}  // end of namespace dynamicgraph.
+
+#endif  //! DYNAMIC_GRAPH_EXCEPTION_TRACES_H

include/dynamic-graph/factory.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_FACTORY_HH
+#define DYNAMIC_GRAPH_FACTORY_HH
+#include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/exception-factory.h>
+
+#include <boost/noncopyable.hpp>
+#include <dynamic-graph/fwd.hh>
+#include <map>
+#include <string>
+#include <vector>
+
+/// \ingroup dgraph
+///
+/// \brief Automatically register a class to the global factory
+/// by relying on the static initialization.
+///
+/// \param CLASSTYPE the Entity type to be registered
+/// \param CLASSNAME the name of the Entity to be registered (this must
+///        be a std::string or a type implicitly castable into a std::string
+///        such as classic C string delimited by double quotes).
+#define DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CLASSTYPE, CLASSNAME)              \
+  const std::string CLASSTYPE::CLASS_NAME = CLASSNAME;                        \
+  extern "C" {                                                                \
+  ::dynamicgraph::Entity *EntityMaker_##CLASSTYPE(                            \
+      const std::string &objname) {                                           \
+    return new CLASSTYPE(objname);                                            \
+  }                                                                           \
+  ::dynamicgraph::EntityRegisterer reg_##CLASSTYPE(CLASSNAME,                 \
+                                                   &EntityMaker_##CLASSTYPE); \
+  }                                                                           \
+  struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n
+
+namespace dynamicgraph {
+/// \ingroup dgraph
+///
+/// \brief Provides a way to create Entity objects from their class
+/// name.
+///
+/// The dynamic graph frameworks relies on entities (see Entity)
+/// which defines atomic processing units. This class provides a
+/// robust way to enumerate and instantiate these entities.
+/// Each entity has a name (its type name) and can be instantiated.
+/// Each instance also has a name.
+///
+/// For instance one can define a C++ class called MyEntity which
+/// inherits from dynamicgraph::Entity. This type can be registered
+/// into the factory to teach the framework that:
+/// - this entity exists
+/// - this entity can be instantiated (and how to instantiate it).
+///
+/// To achieve this, one must pass an entity name and a function pointer.
+///
+/// The entity name will identify the class <b>at run-time</b>
+/// (be careful: this may not be equivalent to the C++ class name
+/// even if it is recommended to do so).
+///
+/// The function pointer must point on a function taking a string as
+/// input and returning an instance of the Entity (the concrete
+/// subclass, not directly the upper Entity class).
+///
+/// The instances returned by this function <b>must</b> be
+/// dynamically allocated and the caller <b>must</b> get the
+/// ownership of the instance (i.e. it will free it when required).
+///
+/// To finish, please note that the instance name indicates to the
+/// entity how the instance itself is called at run-time.  This name
+/// does not need to be unique and no check is done on it.  It is
+/// the caller responsibility to make sure that the instance name is
+/// appropriate and to check for uniqueness if required.
+///
+///
+/// This class is a singleton. The rationale is that each
+/// unique name must identify a unique Entity. The use of a single
+/// instance of this class enforces this behavior, instantiating one
+/// yourself would break this property.
+class DYNAMIC_GRAPH_DLLAPI FactoryStorage : private boost::noncopyable {
+ public:
+  /// \brief Function pointer providing an entity instance from its
+  /// name.
+  typedef Entity *(*EntityConstructor_ptr)(const std::string &);
+
+  ~FactoryStorage();
+
+  /// \brief Get pointer to unique object of the class
+  static FactoryStorage *getInstance();
+
+  /// \brief Destroy the unique instance of the class
+  static void destroy();
+
+  /// \brief Add a new entity to the factory.
+  ///
+  /// It is not allowed to have several entities using the same
+  /// name. If this is the case, an ExceptionFactory exception will
+  /// be raised with the code OBJECT_CONFLICT.
+  ///
+  /// If the function pointer is null, an ExceptionFactory exception
+  /// will be raised with the code OBJECT_CONFLICT.
+  ///
+  /// \param entname the name used to subscribe the entity.
+  /// \param ent pointer to a function allocating an entity from an
+  /// instance name.
+  void registerEntity(const std::string &entname, EntityConstructor_ptr ent);
+
+  /// \brief Delete an entity from the factory.
+  ///
+  /// If the provided entity name does not exist in the factory,
+  /// an ExceptionFactory exception will be raised with the code
+  /// OBJECT_CONFLICT.
+  ///
+  /// \param entname the entity name (as passed to registerEntity before)
+  void deregisterEntity(const std::string &entname);
+
+  /// \brief Instantiate (and allocate) an entity.
+  ///
+  /// An instance called objname of the entity which type is classname
+  /// will be allocated by this method.
+  ///
+  /// It is <b>the caller</b> responsibility to free the
+  /// returned object.
+  ///
+  /// If the class name does not exist, an ExceptionFactory
+  /// exception will be raised with the code UNREFERED_OBJECT.
+  ///
+  /// The instance name (objname) is passed to the Entity
+  /// constructor and it is the caller responsibility to avoid
+  /// instance name conflicts if necessary.
+  ///
+  /// \param classname the name of the Entity type
+  /// \param objname the instance name
+  /// \return Dynamically allocated instance of classname.
+  Entity *newEntity(const std::string &classname,
+                    const std::string &objname) const;
+
+  /// \brief Check if an Entity associated with a particular name
+  /// has already been registered.
+  ///
+  /// \param name entity name
+  /// \return Do the entity exist?
+  bool existEntity(const std::string &name) const;
+
+  /// \brief List the available entities.
+  ///
+  /// Available entities are appended to the method argument.
+  ///
+  /// \param list Available entities will be appended to list.
+  void listEntities(std::vector<std::string> &list) const;
+
+ private:
+  /// \brief Constructor the factory.
+  ///
+  /// After the initialization, no entities will be available.
+  /// registerEntity has to be used to add new entities to the
+  /// object.
+  explicit FactoryStorage();
+
+  /// \brief Entity map type.
+  ///
+  /// This maps entity names to functions pointers which can be
+  /// used to instantiate an Entity.
+  typedef std::map<std::string, EntityConstructor_ptr> EntityMap;
+
+  /// \brief The entity map storing information about how to
+  /// instantiate an Entity.
+  EntityMap entityMap;
+
+  /// \pointer to the unique object of the class
+  static FactoryStorage *instance_;
+};
+
+/// \ingroup dgraph
+///
+/// \brief This class automatically register an Entity to the
+/// global factory at initialization and unregister it during
+/// instance destruction.
+///
+/// This class is mainly used by the
+/// DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN macro and is of little interest
+/// by itself.
+class DYNAMIC_GRAPH_DLLAPI EntityRegisterer : private boost::noncopyable {
+ public:
+  /// \brief Register entity to the global factory.
+  explicit EntityRegisterer(const std::string &entityClassName,
+                            FactoryStorage::EntityConstructor_ptr maker);
+
+  /// \brief Unregister entity to the global factory.
+  ~EntityRegisterer();
+
+ private:
+  /// \brief Name of the entity registered when the instance has
+  /// been initialized.
+  const std::string entityName;
+};
+}  // end of namespace dynamicgraph
+
+#endif  //! DYNAMIC_GRAPH_FACTORY_HH
+
+//  LocalWords:  unregister

include/dynamic-graph/fwd.hh

+// Copyright 2010-2019, CNRS, JRL, AIST, LAAS
+// Thomas Moulard, Olivier Stasse
+//
+
+#ifndef DYNAMIC_GRAPH_FWD_HH
+#define DYNAMIC_GRAPH_FWD_HH
+
+#include <boost/smart_ptr.hpp>
+
+namespace dynamicgraph {
+
+// to be replace by std:: when we switch to C++11 and later
+using boost::const_pointer_cast;
+using boost::dynamic_pointer_cast;
+using boost::make_shared;
+using boost::shared_ptr;
+using boost::static_pointer_cast;
+using boost::weak_ptr;
+
+class DebugTrace;
+
+class PluginRefMap;
+class Entity;
+class EntityRegisterer;
+class ExceptionAbstract;
+class ExceptionFactory;
+class ExceptionSignal;
+class ExceptionTraces;
+class FactoryStorage;
+class Interpreter;
+typedef shared_ptr<Interpreter> InterpreterShPtr_t;
+class InterpreterHelper;
+class Logger;
+class OutStringStream;
+class PluginLoader;
+class PoolStorage;
+
+class Tracer;
+class TracerRealTime;
+
+template <typename T, typename Time>
+class Signal;
+
+template <typename Time>
+class SignalArray;
+
+template <typename Time>
+class SignalArray_const;
+
+template <typename Time>
+class SignalBase;
+
+template <typename T, typename Time>
+class SignalPtr;
+template <typename T, typename Time>
+class SignalTimeDependent;
+template <typename Time>
+class TimeDependency;
+
+namespace command {
+class Command;
+}  // end of namespace command.
+
+}  // end of namespace dynamicgraph.
+
+#endif  //! DYNAMIC_GRAPH_FWD_HH

include/dynamic-graph/linear-algebra.h

+//
+// Copyright 2010 CNRS
+//
+// Author: Florent Lamiraux
+//
+
+#ifndef DYNAMIC_GRAPH_LINEAR_ALGEBRA_H
+#define DYNAMIC_GRAPH_LINEAR_ALGEBRA_H
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+
+namespace dynamicgraph {
+typedef Eigen::MatrixXd Matrix;
+typedef Eigen::VectorXd Vector;
+}  // namespace dynamicgraph
+
+#endif  // DYNAMIC_GRAPH_LINEAR_ALGEBRA_H

include/dynamic-graph/logger.h

+/*
+ * Copyright 2015, 2019
+ * LAAS-CNRS
+ * Andrea Del Prete, François Bailly, Olivier Stasse
+ *
+ */
+
+#ifndef __dynamic_graph_logger_H__
+#define __dynamic_graph_logger_H__
+
+/* --------------------------------------------------------------------- */
+/* --- API ------------------------------------------------------------- */
+/* --------------------------------------------------------------------- */
+
+#if defined(WIN32)
+#if defined(logger_EXPORTS)
+#define LOGGER_EXPORT __declspec(dllexport)
+#else
+#define LOGGER_EXPORT __declspec(dllimport)
+#endif
+#else
+#define LOGGER_EXPORT
+#endif
+
+namespace dynamicgraph {
+
+/** Enum representing the different kind of messages.
+ */
+enum MsgType {
+  MSG_TYPE_TYPE_BITS = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3,  // 15
+  MSG_TYPE_STREAM_BIT = 1 << 4,                            // 16
+
+  MSG_TYPE_DEBUG = 1 << 3,                                           // 1
+  MSG_TYPE_INFO = 1 << 2,                                            // 2
+  MSG_TYPE_WARNING = 1 << 1,                                         // 4
+  MSG_TYPE_ERROR = 1 << 0,                                           // 8
+  MSG_TYPE_DEBUG_STREAM = MSG_TYPE_DEBUG | MSG_TYPE_STREAM_BIT,      // 17
+  MSG_TYPE_INFO_STREAM = MSG_TYPE_INFO | MSG_TYPE_STREAM_BIT,        // 18
+  MSG_TYPE_WARNING_STREAM = MSG_TYPE_WARNING | MSG_TYPE_STREAM_BIT,  // 20
+  MSG_TYPE_ERROR_STREAM = MSG_TYPE_ERROR | MSG_TYPE_STREAM_BIT       // 24
+};
+}  // namespace dynamicgraph
+
+/* --------------------------------------------------------------------- */
+/* --- INCLUDE --------------------------------------------------------- */
+/* --------------------------------------------------------------------- */
+
+#include <map>
+/// \todo These 3 headers should be removed.
+#include <dynamic-graph/linear-algebra.h>
+#include <dynamic-graph/real-time-logger-def.h>
+
+#include <boost/assign.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <dynamic-graph/deprecated.hh>
+#include <fstream>
+#include <iomanip>  // std::setprecision
+#include <sstream>
+
+namespace dynamicgraph {
+
+//#define LOGGER_VERBOSITY_INFO_WARNING_ERROR
+#define LOGGER_VERBOSITY_ALL
+
+#define SEND_MSG(msg, type) \
+  sendMsg(msg, type, __FILE__ ":" BOOST_PP_STRINGIZE(__LINE__))
+
+#define SEND_DEBUG_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_DEBUG_STREAM)
+#define SEND_INFO_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_INFO_STREAM)
+#define SEND_WARNING_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_WARNING_STREAM)
+#define SEND_ERROR_STREAM_MSG(msg) SEND_MSG(msg, MSG_TYPE_ERROR_STREAM)
+
+#define _DYNAMIC_GRAPH_ENTITY_MSG(entity, type) \
+  (entity).logger().stream(type, __FILE__ BOOST_PP_STRINGIZE(__LINE__))
+
+#define DYNAMIC_GRAPH_ENTITY_DEBUG(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_DEBUG)
+#define DYNAMIC_GRAPH_ENTITY_INFO(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_INFO)
+#define DYNAMIC_GRAPH_ENTITY_WARNING(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_WARNING)
+#define DYNAMIC_GRAPH_ENTITY_ERROR(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_ERROR)
+
+#define DYNAMIC_GRAPH_ENTITY_DEBUG_STREAM(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_DEBUG_STREAM)
+#define DYNAMIC_GRAPH_ENTITY_INFO_STREAM(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_INFO_STREAM)
+#define DYNAMIC_GRAPH_ENTITY_WARNING_STREAM(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_WARNING_STREAM)
+#define DYNAMIC_GRAPH_ENTITY_ERROR_STREAM(entity) \
+  _DYNAMIC_GRAPH_ENTITY_MSG(entity, MSG_TYPE_ERROR_STREAM)
+
+template <typename T>
+std::string toString(const T &v, const int precision = 3,
+                     const int width = -1) {
+  std::stringstream ss;
+  if (width > precision)
+    ss << std::fixed << std::setw(width) << std::setprecision(precision) << v;
+  else
+    ss << std::fixed << std::setprecision(precision) << v;
+  return ss.str();
+}
+
+template <typename T>
+std::string toString(const std::vector<T> &v, const int precision = 3,
+                     const int width = -1, const std::string separator = ", ") {
+  std::stringstream ss;
+  if (width > precision) {
+    for (unsigned int i = 0; i < v.size() - 1; i++)
+      ss << std::fixed << std::setw(width) << std::setprecision(precision)
+         << v[i] << separator;
+    ss << std::fixed << std::setw(width) << std::setprecision(precision)
+       << v[v.size() - 1];
+  } else {
+    for (unsigned int i = 0; i < v.size() - 1; i++)
+      ss << std::fixed << std::setprecision(precision) << v[i] << separator;
+    ss << std::fixed << std::setprecision(precision) << v[v.size() - 1];
+  }
+
+  return ss.str();
+}
+
+template <typename T>
+std::string toString(const Eigen::MatrixBase<T> &v, const int precision = 3,
+                     const int width = -1, const std::string separator = ", ") {
+  std::stringstream ss;
+  if (width > precision) {
+    for (unsigned int i = 0; i < v.size() - 1; i++)
+      ss << std::fixed << std::setw(width) << std::setprecision(precision)
+         << v[i] << separator;
+    ss << std::fixed << std::setw(width) << std::setprecision(precision)
+       << v[v.size() - 1];
+  } else {
+    for (unsigned int i = 0; i < v.size() - 1; i++)
+      ss << std::fixed << std::setprecision(precision) << v[i] << separator;
+    ss << std::setprecision(precision) << v[v.size() - 1];
+  }
+
+  return ss.str();
+}
+
+enum LoggerVerbosity {
+  VERBOSITY_ALL = MSG_TYPE_DEBUG,
+  VERBOSITY_INFO_WARNING_ERROR = MSG_TYPE_INFO,
+  VERBOSITY_WARNING_ERROR = MSG_TYPE_WARNING,
+  VERBOSITY_ERROR = MSG_TYPE_ERROR,
+  VERBOSITY_NONE = 0
+};
+
+/// \ingroup debug
+///
+/// \brief Class for logging messages
+///
+/// It is intended to be used like this:
+/// \code
+/// #define ENABLE_RT_LOG
+/// #include <dynamic-graph/real-time-logger.h>
+///
+/// // Somewhere in the main function of your executable
+/// int main (int argc, char** argv) {
+///   std::ofstream of;
+///   of.open("/tmp/dg-LOGS.txt",std::ofstream::out|std::ofstream::app);
+///   dgADD_OSTREAM_TO_RTLOG (of);
+/// }
+///
+/// // Somewhere in your library
+/// dynamicgraph::LoggerVerbosity aLoggerVerbosityLevel =
+///   VERBOSITY_WARNING_ERROR;
+/// entity.setLoggerVerbosityLevel(aLoggerVerbosityLevel);
+/// ...
+/// // using macros
+/// DYNAMIC_GRAPH_ENTITY_WARNING(entity) << "your message\n";
+///
+/// // or the equivalent code without macros:
+/// // Please use '\n' instead of std::endl and flushing will have no effect
+/// entity.logger.stream(dynamicgraph::MSG_TYPE_WARNING,
+///                      __FILE__ BOOST_PP_STRINGIZE(__LINE__))
+///   << your message << '\n';
+///
+/// \endcode
+///
+/// \todo remove m_timeSample and streamPrintPeriod to rather use a simple
+///       integer counting the number of calls. This will achieve exactly the
+///       same behaviour without rouding numerical errors.
+class Logger {
+ public:
+  /** Constructor */
+  Logger(double timeSample = 0.001, double streamPrintPeriod = 1.0);
+
+  /** Destructor */
+  ~Logger();
+
+  /** Method to be called at every control iteration
+   * to decrement the internal Logger's counter. */
+  void countdown();
+
+  /** Get an output stream independently of the debug level.
+   */
+  RTLoggerStream stream() {
+    return ::dynamicgraph::RealTimeLogger::instance().front();
+  }
+
+  /** Print the specified message on standard output if the verbosity level
+   * allows it. The lineId is used to identify the point where sendMsg is
+   * called so that streaming messages are printed only every streamPrintPeriod
+   * iterations.
+   * \param type specifies the verbosity level, for instance MSG_TYPE_DEBUG
+   * \param lineId typically __FILE__ ":" BOOST_PP_STRINGIZE(__LINE__)
+   */
+  RTLoggerStream stream(MsgType type, const std::string &lineId = "") {
+    RealTimeLogger &rtlogger = ::dynamicgraph::RealTimeLogger::instance();
+    if (acceptMsg(type, lineId)) return rtlogger.front();
+    return rtlogger.emptyStream();
+  }
+
+  /** \deprecated instead, use
+   *  \code
+   *    stream(type, lineId) << msg << '\n';
+   *  \endcode
+   */
+  [[deprecated("use stream(type, lineId) << msg")]] void sendMsg(
+      std::string msg, MsgType type, const std::string &lineId = "");
+
+  /** \deprecated instead, use
+   *  \code
+   *    stream(type, lineId) << msg << '\n';
+   *  \endcode
+   */
+  [[deprecated("use stream(type, lineId) << msg")]] void sendMsg(
+      std::string msg, MsgType type, const std::string &file, int line);
+
+  /** Set the sampling time at which the method countdown()
+   * is going to be called. */
+  bool setTimeSample(double t);
+
+  /** Get the sampling time at which the method countdown()
+   * is going to be called. */
+  double getTimeSample();
+
+  /** Set the time period for printing of streaming messages. */
+  bool setStreamPrintPeriod(double s);
+
+  /** Get the time period for printing of streaming messages. */
+  double getStreamPrintPeriod();
+
+  /** Set the verbosity level of the logger. */
+  void setVerbosity(LoggerVerbosity lv);
+
+  /** Get the verbosity level of the logger. */
+  LoggerVerbosity getVerbosity();
+
+ protected:
+  LoggerVerbosity m_lv;  /// verbosity of the logger
+  double m_timeSample;
+  /// specify the period of call of the countdown method
+  double m_streamPrintPeriod;  /// specify the time period of the stream prints
+  double m_printCountdown;
+  /// every time this is < 0 (i.e. every _streamPrintPeriod sec) print stuff
+
+  typedef std::map<std::string, double> StreamCounterMap_t;
+  /** Pointer to the dynamic structure which holds
+      the collection of streaming messages */
+  StreamCounterMap_t m_stream_msg_counters;
+
+  inline bool isStreamMsg(MsgType m) { return (m & MSG_TYPE_STREAM_BIT); }
+
+  /** Check whether a message of type \p m and from \p c lineId should be
+   * accepted. \note If \p m is a stream type, the internal counter associated
+   * to \p lineId is updated.
+   */
+  bool acceptMsg(MsgType m, const std::string &lineId) {
+    // If more verbose than the current verbosity level
+    if ((m & MSG_TYPE_TYPE_BITS) > m_lv) return false;
+
+    // if print is allowed by current verbosity level
+    if (isStreamMsg(m)) return checkStreamPeriod(lineId);
+    return true;
+  }
+
+  /** Check whether a message from \c lineId should be accepted.
+   *  \note The internal counter associated to \c lineId is updated.
+   */
+  bool checkStreamPeriod(const std::string &lineId);
+};
+
+}  // namespace dynamicgraph
+
+#endif  // #ifndef __sot_torque_control_logger_H__

src/dgraph/pool.h → include/dynamic-graph/pool.h

-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- * Copyright Projet JRL-Japan, 2007
- *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- *
- * File:      pool.h
- * Project:   SOT
- * Author:    François Bleibel (from Nicolas Mansard)
- *
- * Version control
- * ===============
- *
- *  $Id$
- *
- * Description
- * ============
- *
- *
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-
-#ifndef POOL_H_
-#define POOL_H_
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/* --- STD --- */
-#include <map>
-#include <string>
-#include <sstream>
-
-/* --- SOT --- */
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_POOL_H
+#define DYNAMIC_GRAPH_POOL_H
+#include <dynamic-graph/dynamic-graph-api.h>
 #include <dynamic-graph/exception-factory.h>
 #include <dynamic-graph/signal-base.h>
-#include <dynamic-graph/dynamic-graph-API.h>
-
-namespace dynamicgraph
-{
 
-class Entity;
-
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
+#include <dynamic-graph/fwd.hh>
+#include <map>
+#include <sstream>
+#include <string>
 
+namespace dynamicgraph {
 /*! @ingroup dgraph
-  \brief This class keep tracks of all the objects in the stack of Tasks.
+  \brief Singleton that keeps track of all the entities.
 
   This class gives access to and remembers all the entities created
   during its life.
@@ -57,81 +29,90 @@ class Entity;
   \note From the code it is not very clear why we should not unregister
   from the tasks and the features...
 
-  The role of this class is also to look for the object supporting
-  a command, and to apply this command.
-
-  It also returns signal.
-
- */
-class DYNAMICGRAPH_EXPORT PoolStorage
-{
+*/
+class DYNAMIC_GRAPH_DLLAPI PoolStorage {
  public:
   /*! \name Define types to simplify the writing
     @{
-   */
+  */
   /*! \brief Sorted set of entities with unique key (name). */
-  typedef std::map< std::string,Entity* > Entities;
+  typedef std::map<std::string, Entity *> Entities;
 
- protected:
-  /*! \name Fields of the class to manage the three entities.
-    Also the name is singular, those are true sets.
-    @{
-  */
-  /*! \brief Set of basic objects of the SoT */
-  Entities entity;
+  /// \brief Get unique instance of the class.
+  static PoolStorage *getInstance();
+
+  /// \brief Destroy the unique instance of the class
+  static void destroy();
+
+  /*! @} */
 
- public:
   /*! \brief Default destructor */
-  ~PoolStorage( void );
+  ~PoolStorage();
 
   /*! \name Method related to the handling of entities.
     @{
-   */
+  */
   /*! \brief Register an entity.
     \par[in] entname: The name of the entity,
     \par[in] ent: Pointer towards the entity.
   */
-  void registerEntity( const std::string& entname,Entity* ent );
+  void registerEntity(const std::string &entname, Entity *ent);
 
   /*! \brief Unregister an entity.
     \par[in] entname: The name of the entity,
   */
-  void deregisterEntity( const std::string& entname );
+  void deregisterEntity(const std::string &entname);
 
+  /*! \brief Unregister an entity.
+    \par[in] entity: iterator in the map,
+  */
+  void deregisterEntity(const Entities::iterator &entity);
   /*! \brief Get an entity.
     \par[in] entname: The name of the entity,
     \return Pointer towards the entity.
   */
-  Entity& getEntity( const std::string& name );
+  Entity &getEntity(const std::string &name);
+
+  /// Const access to entity map
+  const Entities &getEntityMap() const;
+
+  /*! \brief Test if the entity exists. */
+  bool existEntity(const std::string &name);
+  /*! \brief Test if the entity exists. If it does, return a pointer on it. */
+  bool existEntity(const std::string &name, Entity *&ptr);
 
   /*! \brief Disallocate an entity.
     \par[in] entname: The name of the entity,
   */
-  void clearPlugin( const std::string& name );
+  void clearPlugin(const std::string &name);
   /*! @} */
 
+  ///
+  /// \brief Get a signal by name
+  ///
+  /// \param sigpath stream containing a string of the form "entity.signal"
+  SignalBase<int> &getSignal(std::istringstream &sigpath);
 
-  /*! \brief Get a reference to a signal. */
-  SignalBase<int>& getSignal( std::istringstream& sigpath );
-
-  /*! \brief This method looks for the object named objectName,
-    and ask to provide the function functionName with the arguments cmdArg.
-    If the method of the object displays some information this will
-    be done on os.
+  /*! \brief This method write a graph description on the file named
+      FileName. */
+  void writeGraph(const std::string &aFileName);
+  void writeCompletionList(std::ostream &os);
 
-    The commands specific to the <b>pool<\b> object are:
-    \li <b>list</b> : List all the entities registered in the pool.s
+ protected:
+  /*! \name Fields of the class to manage the three entities.
+    Also the name is singular, those are true sets.
+    @{
   */
-  void commandLine( const std::string& objectName,const std::string& functionName,
-		    std::istringstream& cmdArg, std::ostream& os );
+  /*! \brief Set of basic objects of the SoT */
+  Entities entityMap;
 
-  /*! \brief This method write a graph description on the file named FileName. */
-  void writeGraph(const std::string &aFileName);
-  void writeCompletionList(std::ostream& os);
+ private:
+  PoolStorage() {}
+  static PoolStorage *instance_;
 };
 
-DYNAMICGRAPH_EXPORT extern dynamicgraph::PoolStorage pool;
+inline PoolStorage &g_pool() { return *PoolStorage::getInstance(); }
 
-}  // namespace dynamicgraph
+}  // end of namespace dynamicgraph.
 
-#endif /* POOL_H_ */
+#endif  //! DYNAMIC_GRAPH_POOL_H

include/dynamic-graph/process-list.hh

+/* Copyright LAAS, CNRS
+ * Author: O. Stasse, 2019
+ * See LICENSE file in the root directory of this repository.
+ */
+
+#ifndef DYNAMIC_GRAPH_PROCESS_LIST_H_
+#define DYNAMIC_GRAPH_PROCESS_LIST_H_
+
+#include <dynamic-graph/dynamic-graph-api.h>
+
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/serialization/vector.hpp>
+#include <dynamic-graph/fwd.hh>
+
+namespace dynamicgraph {
+namespace CPU {
+class DYNAMIC_GRAPH_DLLAPI ProcessData {};
+
+class DYNAMIC_GRAPH_DLLAPI ProcessList {
+ public:
+  ProcessList();
+};
+
+/// This class gather information on a specific CPU.
+///
+class DYNAMIC_GRAPH_DLLAPI CPUData {
+ public:
+  CPUData();
+  int cpu_id_;
+
+  inline unsigned long long int computePeriod(unsigned long long int &a,
+                                              unsigned long long int &b) {
+    return (a > b) ? a - b : 0;
+  }
+
+  /// \brief Various classes of time spend by the CPU
+  /// @{
+  /// Total time
+  unsigned long long int total_time_;
+  /// Time spend in user mode
+  unsigned long long int user_mode_time_;
+  /// Time spend in user mode with low priority (nice mode)
+  unsigned long long int nice_time_;
+  /// Time spend in system mode
+  unsigned long long int system_time_;
+  /// Time spend in system mode
+  unsigned long long int system_all_time_;
+  /// Time spend in doing nothing.
+  unsigned long long int idle_time_;
+  /// Time spend in doing nothing.
+  unsigned long long int idle_all_time_;
+  /// Time spend in waiting an input/output to complete.
+  unsigned long long int iowait_time_;
+  /// Time spend in servicing hardware interrupts.
+  unsigned long long int irq_time_;
+  /// Time spend in servicing software interrupts.
+  unsigned long long int softirq_time_;
+  /// Time spend in other operating systems in a virtualized environments
+  /// Never doing this for control !
+  unsigned long long int steal_time_;
+  /// Time spend running a virtual CPU for guest operating systems
+  /// under the control of the Linux kernel
+  unsigned long long int guest_time_;
+  /// Time spent running a niced guest
+  /// (virtual CPU for guest operating systems under the
+  /// control of the Linux kernel)
+  unsigned long long int guest_nice_time_;
+  /// @}
+
+  /// \brief Various classes of time spend by the CPU by period
+  /// @{
+  /// Total time
+  unsigned long long int total_period_;
+  /// Time spend in user mode
+  unsigned long long int user_mode_period_;
+  /// Time spend in user mode with low priority (nice mode)
+  unsigned long long int nice_period_;
+  /// Time spend in system mode
+  unsigned long long int system_period_;
+  /// Time spend in all system mode
+  unsigned long long int system_all_period_;
+  /// Time spend in doing nothing.
+  unsigned long long int idle_period_;
+  /// Time spend in doing nothing.
+  unsigned long long int idle_all_period_;
+  /// Time spend in waiting an input/output to complete.
+  unsigned long long int iowait_period_;
+  /// Time spend in servicing hardware interrupts.
+  unsigned long long int irq_period_;
+  /// Time spend in servicing software interrupts.
+  unsigned long long int softirq_period_;
+  /// Time spend in other operating systems in a virtualized environments
+  /// Never doing this for control !
+  unsigned long long int steal_period_;
+  /// Time spend running a virtual CPU for guest operating systems
+  /// under the control of the Linux kernel
+  unsigned long long int guest_period_;
+  /// @}
+
+  double percent_;
+  void ProcessLine(std::istringstream &aCPULine);
+
+  friend class boost::serialization::access;
+
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int version) {
+    ar &version;
+    ar &total_time_;
+    ar &user_mode_time_;
+    ar &nice_time_;
+    ar &system_time_;
+    ar &system_all_time_;
+    ar &idle_time_;
+    ar &idle_all_time_;
+    ar &iowait_time_;
+    ar &irq_time_;
+    ar &softirq_time_;
+    ar &steal_time_;
+    ar &guest_time_;
+    ar &guest_nice_time_;
+    ar &percent_;
+  }
+};
+
+/// This class gathers information on a computer.
+/// This includes a list of CPU
+class DYNAMIC_GRAPH_DLLAPI System {
+ private:
+  bool init_;
+
+ public:
+  System();
+
+  /// Read /proc/state file to extract CPU count.
+  void init();
+
+  /// Update CPU data information from /proc/stat
+  void readProcStat();
+
+  /// Friend class for serialization.
+  friend class boost::serialization::access;
+
+  /// Number of CPU.
+  unsigned int cpuNb_;
+
+  void ProcessCPULine(unsigned int cpunb, std::istringstream &aCPULine);
+
+  /// \brief Vector of CPU informations.
+  std::vector<CPUData> vCPUData_;
+
+  /// \brief Global CPU information.
+  CPUData gCPUData_;
+
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int version) {
+    ar &version;
+    ar &cpuNb_;
+    ar &gCPUData_;
+    ar &vCPUData_;
+  }
+};
+}  // namespace CPU
+}  // namespace dynamicgraph
+
+#endif /* DYNAMIC_GRAPH_PROCESS_LIST_H_ */

include/dynamic-graph/real-time-logger-def.h

+// -*- mode: c++ -*-
+// Copyright 2018, Joseph Mirabel LAAS-CNRS
+//
+
+#ifndef DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
+#define DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/mutex.hpp>
+#include <dynamic-graph/config.hh>
+#include <sstream>
+#include <vector>
+
+namespace dynamicgraph {
+/// \ingroup debug
+///
+/// \brief Stream for the real-time logger.
+///
+/// You should inherit from this class in order to redirect the logs where you
+/// want.
+/// \sa LoggerIOStream
+class LoggerStream {
+ public:
+  virtual void write(const char *c) = 0;
+};
+
+/// Write to an ostream object.
+///
+/// The easieast is to use the macro  dgADD_OSTREAM_TO_RTLOG(ostr) where
+/// `ostr` can be `std::cout` or an std::ofstream...
+class LoggerIOStream : public LoggerStream {
+ public:
+  LoggerIOStream(std::ostream &os) : os_(os) {}
+  virtual ~LoggerIOStream() {}
+  virtual void write(const char *c) { os_ << c; }
+
+ private:
+  std::ostream &os_;
+};
+typedef boost::shared_ptr<LoggerStream> LoggerStreamPtr_t;
+
+class RealTimeLogger;
+
+/// \cond DEVEL
+/// \brief write entries to intenal buffer.
+///
+/// The entry starts when an instance is created and ends when is is deleted.
+/// This class is only used by RealTimeLogger.
+class RTLoggerStream {
+ public:
+  inline RTLoggerStream(RealTimeLogger *logger, std::ostream &os)
+      : ok_(logger != NULL), logger_(logger), os_(os) {}
+  template <typename T>
+  inline RTLoggerStream &operator<<(T t) {
+    if (ok_) os_ << t;
+    return *this;
+  }
+  inline RTLoggerStream &operator<<(std::ostream &(*pf)(std::ostream &)) {
+    if (ok_) os_ << pf;
+    return *this;
+  }
+
+  inline ~RTLoggerStream();
+
+  inline bool isNull() { return !ok_; }
+
+ private:
+  const bool ok_;
+  RealTimeLogger *logger_;
+  std::ostream &os_;
+};
+/// \endcond DEVEL
+
+/// \ingroup debug
+///
+/// \brief Main class of the real-time logger.
+///
+/// It is intended to be used like this:
+/// \code
+/// #define ENABLE_RT_LOG
+/// #include <dynamic-graph/real-time-logger.h>
+///
+/// // Somewhere in the main function of your executable
+/// int main (int argc, char** argv) {
+///   dgADD_OSTREAM_TO_RTLOG (std::cout);
+/// }
+///
+/// // Somewhere in your library
+/// dgRTLOG() << "your message. Prefer to use \n than std::endl."
+/// \endcode
+///
+/// \note Thread safety. This class expects to have:
+/// - only one reader: the one who take the log entries and write them
+///   somewhere.
+/// - one writer at a time. Writing to the logs is **never** a blocking
+///   operation. If the resource is busy, the log entry is discarded.
+class DYNAMIC_GRAPH_DLLAPI RealTimeLogger {
+ public:
+  static RealTimeLogger &instance();
+
+  static void destroy();
+
+  /// \todo add an argument to preallocate the internal string
+  /// to a given size.
+  RealTimeLogger(const std::size_t &bufferSize);
+
+  inline void clearOutputStreams() { outputs_.clear(); }
+
+  inline void addOutputStream(const LoggerStreamPtr_t &os) {
+    outputs_.push_back(os);
+  }
+
+  /// Write next message to output.
+  /// It does nothing if the buffer is empty.
+  /// \return true if it wrote something
+  bool spinOnce();
+
+  /// Return an object onto which a real-time thread can write.
+  /// The message is considered finished when the object is destroyed.
+  RTLoggerStream front();
+
+  /// Return an empty stream object.
+  RTLoggerStream emptyStream() { return RTLoggerStream(NULL, oss_); }
+
+  inline void frontReady() {
+    backIdx_ = (backIdx_ + 1) % buffer_.size();
+    wmutex.unlock();
+  }
+
+  inline bool empty() const { return frontIdx_ == backIdx_; }
+
+  inline bool full() const {
+    return ((backIdx_ + 1) % buffer_.size()) == frontIdx_;
+  }
+
+  inline std::size_t size() const {
+    if (frontIdx_ <= backIdx_)
+      return backIdx_ - frontIdx_;
+    else
+      return backIdx_ + buffer_.size() - frontIdx_;
+  }
+
+  inline std::size_t getBufferSize() { return buffer_.size(); }
+
+  ~RealTimeLogger();
+
+ private:
+  struct Data {
+    std::stringbuf buf;
+  };
+
+  std::vector<LoggerStreamPtr_t> outputs_;
+  std::vector<Data *> buffer_;
+  /// Index of the next value to be read.
+  std::size_t frontIdx_;
+  /// Index of the slot where to write next value
+  /// (does not contain valid data).
+  std::size_t backIdx_;
+  std::ostream oss_;
+
+  /// The writer mutex.
+  boost::mutex wmutex;
+  std::size_t nbDiscarded_;
+
+  struct thread;
+
+  static RealTimeLogger *instance_;
+  static thread *thread_;
+};
+
+RTLoggerStream::~RTLoggerStream() {
+  if (ok_) {
+    os_ << std::ends;
+    logger_->frontReady();
+  }
+}
+
+}  // end of namespace dynamicgraph
+
+#endif  //! DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H

include/dynamic-graph/real-time-logger.h

+// -*- mode: c++ -*-
+// Copyright 2018, Joseph Mirabel LAAS-CNRS
+//
+
+#ifndef DYNAMIC_GRAPH_LOGGER_REAL_TIME_H
+#define DYNAMIC_GRAPH_LOGGER_REAL_TIME_H
+
+#ifdef ENABLE_RT_LOG
+#define dgADD_OSTREAM_TO_RTLOG(ostr)                          \
+  ::dynamicgraph::RealTimeLogger::instance().addOutputStream( \
+      ::dynamicgraph::LoggerStreamPtr_t(                      \
+          new ::dynamicgraph::LoggerIOStream(ostr)))
+
+#define dgRTLOG() ::dynamicgraph::RealTimeLogger::instance().front()
+#else  // ENABLE_RT_LOG
+#define dgADD_OSTREAM_TO_RTLOG(ostr) struct __end_with_semicolon
+#define dgRTLOG() \
+  if (1)          \
+    ;             \
+  else            \
+    __null_stream()
+#endif
+
+#include <dynamic-graph/real-time-logger-def.h>
+
+#endif  //! DYNAMIC_GRAPH_LOGGER_REAL_TIME_H

include/dynamic-graph/signal-array.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_ARRAY_H
+#define DYNAMIC_GRAPH_SIGNAL_ARRAY_H
+#include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/signal-base.h>
+#include <stdio.h>
+
+#include <vector>
+
+namespace dynamicgraph {
+
+/// \ingroup dgraph
+///
+/// \brief TODO
+template <class Time>
+class SignalArray_const {
+ public:
+  static const int DEFAULT_SIZE = 20;
+
+ protected:
+  std::vector<const SignalBase<Time> *> const_array;
+  unsigned int size, rank;
+
+ public:
+  SignalArray_const<Time>(const unsigned int &sizeARG = DEFAULT_SIZE)
+      : const_array(sizeARG), size(sizeARG), rank(0) {}
+
+  SignalArray_const<Time>(const SignalBase<Time> &sig)
+      : const_array(DEFAULT_SIZE), size(DEFAULT_SIZE), rank(0) {
+    addElmt(&sig);
+  }
+
+  SignalArray_const<Time>(const SignalArray<Time> &siga)
+      : const_array(siga.getSize()),
+        size(siga.getSize()),
+        rank(siga.getSize()) {
+    for (unsigned int i = 0; i < rank; ++i) const_array[i] = &siga[i];
+  }
+
+  SignalArray_const<Time>(const SignalArray_const<Time> &siga)
+      : const_array(siga.getSize()),
+        size(siga.getSize()),
+        rank(siga.getSize()) {
+    for (unsigned int i = 0; i < rank; ++i) const_array[i] = &siga[i];
+  }
+
+  virtual ~SignalArray_const<Time>() {}
+
+ protected:
+  void addElmt(const SignalBase<Time> *el) {
+    if (rank >= size) {
+      size += DEFAULT_SIZE;
+      const_array.resize(size);
+    }
+    const_array[rank++] = el;
+  }
+
+ public:
+  virtual SignalArray_const<Time> &operator<<(const SignalBase<Time> &sig) {
+    addElmt(&sig);
+    return *this;
+  }
+
+ public:
+  virtual const SignalBase<Time> &operator[](const unsigned int &idx) const {
+    return *const_array[idx];
+  }
+  virtual unsigned int getSize() const { return rank; }
+};
+
+template <class Time>
+SignalArray_const<Time> operator<<(const SignalBase<Time> &sig1,
+                                   const SignalBase<Time> &sig2) {
+  SignalArray_const<Time> res(sig1);
+  res << sig2;
+  return res;
+}
+
+/// \ingroup dgraph
+///
+/// \brief TODO
+template <class Time>
+class SignalArray : public SignalArray_const<Time> {
+ public:
+  using SignalArray_const<Time>::DEFAULT_SIZE;
+  using SignalArray_const<Time>::size;
+  using SignalArray_const<Time>::rank;
+
+ protected:
+  mutable std::vector<SignalBase<Time> *> array;
+
+ public:
+  SignalArray<Time>(const unsigned int &sizeARG = DEFAULT_SIZE)
+      : SignalArray_const<Time>(0), array(sizeARG) {
+    size = sizeARG;
+  }
+
+  SignalArray<Time>(SignalBase<Time> &sig)
+      : SignalArray_const<Time>(0), array(DEFAULT_SIZE) {
+    size = DEFAULT_SIZE;
+    addElmt(&sig);
+  }
+
+  SignalArray<Time>(const SignalArray<Time> &siga)
+      : SignalArray_const<Time>(siga.getSize()), array(siga.getSize()) {
+    rank = siga.getSize();
+    for (unsigned int i = 0; i < rank; ++i) array[i] = &siga[i];
+  }
+
+  virtual ~SignalArray<Time>() {}
+
+ protected:
+  void addElmt(SignalBase<Time> *el) {
+    if (rank >= size) {
+      size += DEFAULT_SIZE;
+      array.resize(size);
+    }
+    array[rank++] = el;
+  }
+
+ public:
+  virtual SignalArray<Time> &operator<<(SignalBase<Time> &sig) {
+    addElmt(&sig);
+    return *this;
+  }
+
+  virtual SignalArray_const<Time> operator<<(
+      const SignalBase<Time> &sig) const {
+    SignalArray_const<Time> res(*this);
+    res << sig;
+    return res;
+  }
+
+  virtual SignalBase<Time> &operator[](const unsigned int &idx) const {
+    return *array[idx];
+  }
+};
+
+template <class Time>
+SignalArray<Time> operator<<(SignalBase<Time> &sig1, SignalBase<Time> &sig2) {
+  SignalArray<Time> res(sig1);
+  res << sig2;
+  return res;
+}
+
+DYNAMIC_GRAPH_DLLAPI extern SignalArray<int> sotNOSIGNAL;
+
+}  // end of namespace dynamicgraph.
+
+#endif  //! DYNAMIC_GRAPH_SIGNAL_ARRAY_H

include/dynamic-graph/signal-base.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+// LAAS, CNRS
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_BASE_H
+#define DYNAMIC_GRAPH_SIGNAL_BASE_H
+#include <dynamic-graph/exception-signal.h>
+
+#include <boost/noncopyable.hpp>
+#include <dynamic-graph/fwd.hh>
+#include <sstream>
+#include <string>
+#include <typeinfo>
+
+namespace dynamicgraph {
+
+/** \brief The base class for signals: not to be used as such.
+
+    Signal values can be accessed programmatically using the access
+    () or accessCopy () methods; the former directly accesses the
+    value of the signal, which can involve an extra computation,
+    while the latter accesses a cached value, or 'copy'.
+*/
+template <class Time>
+class SignalBase : public boost::noncopyable {
+ public:
+  explicit SignalBase(std::string name = "")
+      : name(name), signalTime(0), ready(false) {}
+
+  virtual ~SignalBase() {}
+
+  /// \name Time
+  /// \{
+  virtual const Time &getTime() const { return signalTime; }
+
+  virtual void setTime(const Time &t) { signalTime = t; }
+
+  const bool &getReady() const { return ready; }
+
+  const std::string &getName() const { return name; }
+
+  void getClassName(std::string &aClassName) const {
+    aClassName = typeid(this).name();
+  }
+
+  virtual void setPeriodTime(const Time &) {}
+
+  virtual Time getPeriodTime() const { return 1; }
+
+  /// \}
+
+  /// \name Dependencies
+  /// \{
+
+  virtual void addDependency(const SignalBase<Time> &) {}
+
+  virtual void removeDependency(const SignalBase<Time> &) {}
+
+  virtual void clearDependencies() {}
+
+  virtual bool needUpdate(const Time &) const { return ready; }
+
+  inline void setReady(const bool sready = true) { ready = sready; }
+
+  virtual std::ostream &writeGraph(std::ostream &os) const { return os; }
+
+  virtual std::ostream &displayDependencies(std::ostream &os, const int = -1,
+                                            std::string space = "",
+                                            std::string next1 = "",
+                                            std::string = "") const {
+    os << space << next1 << "-- ";
+    display(os);
+    return os;
+  }
+
+  /// \}
+
+  /// \name Plug
+  /// \{
+
+  /* Plug the arg-signal on the <this> object. Plug-in is always
+   * a descending operation (the actual <this> object will call the arg-signal
+   * and not the opposite).
+   */
+  virtual void plug(SignalBase<Time> *sigarg) {
+    DG_THROW ExceptionSignal(
+        ExceptionSignal::PLUG_IMPOSSIBLE,
+        "Plug-in operation not possible with this signal. ",
+        "(while trying to plug %s on %s).", sigarg->getName().c_str(),
+        this->getName().c_str());
+  }
+
+  virtual void unplug() {
+    DG_THROW ExceptionSignal(
+        ExceptionSignal::PLUG_IMPOSSIBLE,
+        "Plug-in operation not possible with this signal. ",
+        "(while trying to unplug %s).", this->getName().c_str());
+  }
+
+  virtual bool isPlugged() const { return false; }
+
+  virtual SignalBase<Time> *getPluged() const { return NULL; }
+
+  virtual void setConstantDefault() {
+    DG_THROW ExceptionSignal(
+        ExceptionSignal::PLUG_IMPOSSIBLE,
+        "Plug-in operation not possible with this signal. ",
+        "(while trying to save %s).", this->getName().c_str());
+  }
+
+  /// \}
+
+  /// \name Set
+  /// \{
+
+  /* Generic set function. Should be reimplemented by the specific
+   * Signal.  Sets a signal value
+   */
+  virtual void set(std::istringstream &) {
+    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
+                             "Set operation not possible with this signal. ",
+                             "(while trying to set %s).",
+                             this->getName().c_str());
+  }
+
+  virtual void get(std::ostream &) const {
+    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
+                             "Get operation not possible with this signal. ",
+                             "(while trying to get %s).",
+                             this->getName().c_str());
+  }
+
+  virtual inline void recompute(const Time &) {
+    DG_THROW ExceptionSignal(
+        ExceptionSignal::SET_IMPOSSIBLE,
+        "Recompute operation not possible with this signal. ",
+        "(while trying to recompute %s).", this->getName().c_str());
+  }
+
+  virtual void trace(std::ostream &) const {
+    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
+                             "Trace operation not possible with this signal. ",
+                             "(while trying to trace %s).",
+                             this->getName().c_str());
+  }
+
+  /// \}
+
+  /// \name Display
+  /// \{
+
+  virtual std::ostream &display(std::ostream &os) const {
+    os << "Sig:" << name;
+    return os;
+  }
+
+  std::string shortName() const {
+    std::istringstream iss(name);
+    const int SIZE = 128;
+    char buffer[SIZE];
+    while (iss.good()) {
+      iss.getline(buffer, SIZE, ':');
+    }
+    const std::string res(buffer);
+    return res;
+  }
+  /// \}
+
+  /// \name Information providers
+  /// \{
+
+  virtual void ExtractNodeAndLocalNames(std::string &LocalName,
+                                        std::string &NodeName) const {
+    std::string fullname = this->getName();
+
+    size_t IdxPosLocalName = fullname.rfind(":");
+    LocalName = fullname.substr(IdxPosLocalName + 1,
+                                fullname.length() - IdxPosLocalName + 1);
+    size_t IdxPosNodeNameStart = fullname.find("(");
+    size_t IdxPosNodeNameEnd = fullname.find(")");
+    NodeName = fullname.substr(IdxPosNodeNameStart + 1,
+                               IdxPosNodeNameEnd - IdxPosNodeNameStart - 1);
+  }
+
+  /// \}
+
+  /// \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;
+  bool ready;
+};
+
+/// Forward to a virtual fonction.
+template <class Time>
+std::ostream &operator<<(std::ostream &os, const SignalBase<Time> &sig) {
+  return sig.display(os);
+}
+}  // end of namespace dynamicgraph.
+
+#endif  //! DYNAMIC_GRAPH_SIGNAL_BASE_H

include/dynamic-graph/signal-cast-helper.h

+// -*- c++-mode -*-
+// Copyright 2010 François Bleibel Thomas Moulard, Olivier Stasse,
+// Nicolas Mansard
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HELPER_HH
+#define DYNAMIC_GRAPH_SIGNAL_CASTER_HELPER_HH
+
+#pragma warning "This file is now useless"
+
+#endif  // #ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HELPER_HH

include/dynamic-graph/signal-caster.h

+// -*- c++-mode -*-
+// Copyright 2010 François Bleibel Thomas Moulard, Olivier Stasse
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HH
+#define DYNAMIC_GRAPH_SIGNAL_CASTER_HH
+#include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/eigen-io.h>
+#include <dynamic-graph/linear-algebra.h>
+
+#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <map>
+#include <vector>
+
+#include "dynamic-graph/exception-signal.h"
+
+namespace dynamicgraph {
+
+/// Inherit from this class if you want to keep default implementation for some
+/// functions.
+template <typename T>
+struct signal_io_base {
+  /// serialize a signal value.
+  inline static void disp(const T &value, std::ostream &os) { os << value; }
+  /// deserialize a signal value.
+  inline static T cast(std::istringstream &is) {
+    T inst;
+    is >> inst;
+    if (is.fail()) {
+      throw ExceptionSignal(ExceptionSignal::GENERIC,
+                            "failed to serialize " + is.str());
+    }
+    return inst;
+  }
+  /// write a signal value to log file
+  inline static void trace(const T &value, std::ostream &os) { os << value; }
+};
+
+/// Inherit from this class if tracing is not implemented for a given type.
+template <typename T>
+struct signal_io_unimplemented {
+  inline static void disp(const T &, std::ostream &) {
+    throw std::logic_error("this disp is not implemented.");
+  }
+  inline static T cast(std::istringstream &) {
+    throw std::logic_error("this cast is not implemented.");
+  }
+  inline static void trace(const T &, std::ostream &) {
+    throw std::logic_error("this trace is not implemented.");
+  }
+};
+
+/// Class used for I/O operations in Signal<T,Time>
+template <typename T>
+struct signal_io : signal_io_base<T> {};
+
+/// Template specialization of signal_disp for Eigen objects
+template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
+          int _MaxCols>
+struct signal_io<
+    Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>>
+    : signal_io_base<
+          Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> {
+  typedef Eigen::Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>
+      matrix_type;
+
+  inline static void disp(const matrix_type &value, std::ostream &os) {
+    static const Eigen::IOFormat row_format(
+        Eigen::StreamPrecision, Eigen::DontAlignCols, " ", " ", "", "", "", "");
+    os << value.format(row_format);
+  }
+
+  inline static void trace(const matrix_type &value, std::ostream &os) {
+    static const Eigen::IOFormat row_format(Eigen::StreamPrecision,
+                                            Eigen::DontAlignCols, "\t", "\t",
+                                            "", "", "", "");
+    os << value.format(row_format);
+  }
+};
+
+/// Template specialization of signal_io for Eigen quaternion objects
+template <typename _Scalar, int _Options>
+struct signal_io<Eigen::Quaternion<_Scalar, _Options>>
+    : signal_io_base<Eigen::Quaternion<_Scalar, _Options>> {
+  typedef Eigen::Quaternion<_Scalar, _Options> quat_type;
+  typedef Eigen::Matrix<_Scalar, 4, 1, _Options> matrix_type;
+
+  inline static void disp(const quat_type &value, std::ostream &os) {
+    signal_io<matrix_type>::disp(value.coeffs(), os);
+  }
+
+  inline static quat_type cast(std::istringstream &is) {
+    return quat_type(signal_io<matrix_type>::cast(is));
+  }
+
+  inline static void trace(const quat_type &value, std::ostream &os) {
+    signal_io<matrix_type>::trace(value.coeffs(), os);
+  }
+};
+
+/// Template specialization of signal_io for std::string.
+/// Do not print '\n' at the end.
+template <>
+struct signal_io<std::string> : signal_io_base<std::string> {
+  inline static std::string cast(std::istringstream &iss) { return iss.str(); }
+};
+
+/// Template specialization of signal_io for double
+/// to workaround the limitations of the stream based approach.
+///
+/// When dealing with double: displaying a double on a stream
+/// is *NOT* the opposite of reading a double from a stream.
+///
+/// In practice, it means that there is no way to read
+/// a NaN, +inf, -inf from a stream!
+///
+/// To workaround this problem, parse special values manually
+/// (the strings used are the one produces by displaying special
+/// values on a stream).
+template <>
+struct signal_io<double> : signal_io_base<double> {
+  inline static double cast(std::istringstream &iss) {
+    std::string tmp(iss.str());
+
+    if (tmp == "nan")
+      return std::numeric_limits<double>::quiet_NaN();
+    else if (tmp == "inf" || tmp == "+inf")
+      return std::numeric_limits<double>::infinity();
+    else if (tmp == "-inf")
+      return -1. * std::numeric_limits<double>::infinity();
+
+    try {
+      return boost::lexical_cast<double>(tmp);
+    } catch (boost::bad_lexical_cast &) {
+      boost::format fmt("failed to serialize %s (to double)");
+      fmt % tmp;
+      throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+    }
+  }
+};
+
+}  // end of namespace dynamicgraph.
+
+#endif  //! DYNAMIC_GRAPH_SIGNAL_CASTER_HH

include/dynamic-graph/signal-helper.h

+/*
+ * Copyright 2011, 2019
+ * LAAS-CNRS
+ * Nicolas Mansard, François Bailly
+ *
+ */
+
+#ifndef __dynamic_graph_signal_helper_H__
+#define __dynamic_graph_signal_helper_H__
+
+/* --- COMMON INCLUDE -------------------------------------------------- */
+
+/* dg signals */
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/linear-algebra.h>
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+
+/* --- MACROS ---------------------------------------------------------- */
+#define SIGNAL_OUT_FUNCTION_NAME(name) name##SOUT_function
+
+#define DECLARE_SIGNAL(name, IO, type) \
+  ::dynamicgraph::Signal<type, int> m_##name##S##IO
+#define CONSTRUCT_SIGNAL(name, IO, type)                                    \
+  m_##name##S##IO(getClassName() + "(" + getName() + ")::" + #IO + "put(" + \
+                  #type + ")::" + #name)
+#define BIND_SIGNAL_TO_FUNCTION(name, IO, type) \
+  m_##name##S##IO.setFunction(boost::bind(      \
+      &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name), this, _1, _2));
+
+/**/
+
+#define DECLARE_SIGNAL_IN(name, type) \
+  ::dynamicgraph::SignalPtr<type, int> 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)
+
+#define DEFINE_SIGNAL_OUT_FUNCTION(name, type) \
+  type &EntityClassName::SIGNAL_OUT_FUNCTION_NAME(name)(type & s, int iter)
+
+#define SIGNAL_OUT_FUNCTION(name) name##SOUT_function
+
+#define DECLARE_SIGNAL_OUT(name, type)                           \
+ public:                                                         \
+  ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SOUT; \
+                                                                 \
+ protected:                                                      \
+  type &SIGNAL_OUT_FUNCTION(name)(type &, int)
+
+#define CONSTRUCT_SIGNAL_OUT(name, type, dep)                                \
+  m_##name##SOUT(                                                            \
+      boost::bind(&EntityClassName::name##SOUT_function, this, _1, _2), dep, \
+      getClassName() + "(" + getName() + ")::output(" + #type + ")::" + #name)
+
+/**************** INNER SIGNALS *******************/
+#define SIGNAL_INNER_FUNCTION_NAME(name) name##SINNER_function
+
+#define DECLARE_SIGNAL_INNER_FUNCTION(name, type) \
+  type &SIGNAL_INNER_FUNCTION_NAME(name)(type &, int)
+
+#define DEFINE_SIGNAL_INNER_FUNCTION(name, type) \
+  type &EntityClassName::SIGNAL_INNER_FUNCTION_NAME(name)(type & s, int iter)
+
+#define DECLARE_SIGNAL_INNER(name, type)                           \
+ public:                                                           \
+  ::dynamicgraph::SignalTimeDependent<type, int> m_##name##SINNER; \
+                                                                   \
+ protected:                                                        \
+  DECLARE_SIGNAL_INNER_FUNCTION(name, type)
+
+#define CONSTRUCT_SIGNAL_INNER(name, type, dep)                                \
+  m_##name##SINNER(                                                            \
+      boost::bind(&EntityClassName::name##SINNER_function, this, _1, _2), dep, \
+      getClassName() + "(" + getName() + ")::inner(" + #type + ")::" + #name)
+
+#endif  // __dynamic_graph_signal_helper_H__

include/dynamic-graph/signal-ptr.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_PTR_H
+#define DYNAMIC_GRAPH_SIGNAL_PTR_H
+
+#include <dynamic-graph/exception-signal.h>
+#include <dynamic-graph/signal.h>
+
+namespace dynamicgraph {
+/// \ingroup dgraph
+///
+/// \brief This is the only type of signal that can be plugged to,
+/// using the plug () command.
+///
+/// In that sense, when plugged into, it acts as a "pointer" to the
+/// input signal, hence the name. Operator -> is also overloaded and
+/// can be used to access the pointed signal.
+///
+/// If the signal provided as a parameter of the plug operation
+/// cannot be casted in type T, but is compatible then the class
+/// holds a reference to an abstract object.
+///
+template <class T, class Time>
+class SignalPtr : public virtual Signal<T, Time> {
+ public:
+  using SignalBase<Time>::getName;
+
+ protected:
+  Signal<T, Time> *signalPtr;
+  bool modeNoThrow;
+  bool transmitAbstract;
+  SignalBase<Time> *abstractTransmitter;
+  T *transmitAbstractData;
+
+  inline bool autoref() const { return signalPtr == this; }
+
+ public: /* --- CONSTRUCTORS --- */
+  SignalPtr(Signal<T, Time> *ptr, std::string name = "")
+      : Signal<T, Time>(name),
+        signalPtr(ptr),
+        modeNoThrow(false),
+        transmitAbstract(false),
+        abstractTransmitter(NULL) {}
+
+  virtual ~SignalPtr() { signalPtr = NULL; }
+
+ public:
+  /* --- 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. */
+  inline Signal<T, Time> *operator->() { return getPtr(); }
+  inline const Signal<T, Time> *operator->() const { return getPtr(); }
+  inline Signal<T, Time> &operator*() { return *getPtr(); }
+  inline const Signal<T, Time> &operator*() const { return *getPtr(); }
+  inline operator bool() const { return isPlugged(); }
+
+ public: /* --- INHERITANCE --- */
+  virtual bool needUpdate(const Time &t) const;
+  virtual std::ostream &writeGraph(std::ostream &os) const;
+  virtual std::ostream &display(std::ostream &os) const;
+
+  /* For compatibility, .access () is equivalent to ->access (). For explicit
+   * pointer dereference :
+   * Prefere -> () to ()
+   */
+  virtual const T &operator()(const Time &t);
+  /* Similarly, Prefere ->access to .access
+   */
+  virtual const T &access(const Time &t);
+  virtual const T &accessCopy() const;
+
+  inline void setConstantDefault(const T &t) {
+    Signal<T, Time>::setConstant(t);
+    modeNoThrow = true;
+  }
+  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
+   * the classical mother Signal layer of the object.
+   */
+  virtual void setConstant(const T &t) {
+    plug(this);
+    Signal<T, Time>::setConstant(t);
+  }
+  virtual void setReference(const T *t,
+                            typename Signal<T, Time>::Mutex *m = NULL) {
+    plug(this);
+    Signal<T, Time>::setReference(t, m);
+  }
+  virtual void setFunction(boost::function2<T &, T &, Time> t,
+                           typename Signal<T, Time>::Mutex *m = NULL) {
+    plug(this);
+    Signal<T, Time>::setFunction(t, m);
+  }
+
+  /*     template< class Provider > */
+  /*    void setFunction( T& (Provider::*fun)(Time,T&),Provider& obj, */
+  /*              boost::try_mutex *mutexref=NULL ) */
+  /*    { plug(this); Signal<T,Time>::setFunction(fun,obj,mutexref); } */
+
+  virtual inline Signal<T, Time> &operator=(const T &t) {
+    setConstant(t);
+    return *this;
+  }
+
+  virtual std::ostream &displayDependencies(std::ostream &os,
+                                            const int depth = -1,
+                                            std::string space = "",
+                                            std::string next1 = "",
+                                            std::string next2 = "") const;
+
+ protected:  // Interdiction of the rest of the heritage
+  using Signal<T, Time>::addDependency;
+  virtual void addDependency() {}
+  using Signal<T, Time>::removeDependency;
+  virtual void removeDependency() {}
+  virtual void clearDependencies() {}
+};
+
+}  // end of namespace dynamicgraph
+
+#include <dynamic-graph/signal-ptr.t.cpp>
+#endif  //! DYNAMIC_GRAPH_SIGNAL_PTR_H

include/dynamic-graph/signal-ptr.t.cpp

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_PTR_T_CPP
+#define DYNAMIC_GRAPH_SIGNAL_PTR_T_CPP
+#include <dynamic-graph/signal-ptr.h>
+
+#undef VP_TEMPLATE_DEBUG_MODE
+#define VP_TEMPLATE_DEBUG_MODE 0
+#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);
+  if (!isPlugged()) DG_THROW
+  ExceptionSignal(ExceptionSignal::NOT_INITIALIZED,
+                  "In SignalPtr: SIN ptr not set.", " (in signal <%s>)",
+                  getName().c_str());
+  dgTDEBUGOUT(25);
+  return signalPtr;
+}
+
+template <class T, class Time>
+const Signal<T, Time> *SignalPtr<T, Time>::getPtr() const {
+  dgTDEBUGIN(25) << SignalBase<Time>::name << "(" << isPlugged() << ")" << this
+                 << "->" << signalPtr << std::endl;
+  dgTDEBUGIN(25);
+  if (!isPlugged()) {
+    DG_THROW ExceptionSignal(ExceptionSignal::NOT_INITIALIZED,
+                             "In SignalPtr: SIN ptr not set.",
+                             " (in signal <%s>)", getName().c_str());
+  }
+  dgTDEBUGOUT(25);
+  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;
+  }
+
+  dgTDEBUG(5) << "# In  T = " << getName() << " ="
+              << 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 {
+    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);
+  } 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();
+  }
+  return Signal<T, Time>::getTime();
+}
+
+template <class T, class Time>
+const T &SignalPtr<T, Time>::operator()(const Time &t) {
+  return access(t);
+}
+
+template <class T, class Time>
+const T &SignalPtr<T, Time>::access(const Time &t) {
+  dgTDEBUGIN(15);
+  if (modeNoThrow && (!isPlugged()) && Signal<T, Time>::copyInit) {
+    dgTDEBUGOUT(15);
+    return Signal<T, Time>::accessCopy();
+  } 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);
+  }
+}
+
+template <class T, class Time>
+const T &SignalPtr<T, Time>::accessCopy() const {
+  if (modeNoThrow && (!isPlugged()) && Signal<T, Time>::copyInit)
+    return Signal<T, Time>::accessCopy();
+  else if (autoref())
+    return Signal<T, Time>::accessCopy();
+  else if (transmitAbstract)
+    return *transmitAbstractData;
+  else
+    return getPtr()->accessCopy();
+}
+template <class T, class Time>
+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()) {
+    std::string itLocalName, itNodeName;
+    getAbstractPtr()->ExtractNodeAndLocalNames(itLocalName, itNodeName);
+    os << "\t\"" << itNodeName << "\" -> \"" << LeaderNodeName << "\""
+       << std::endl
+       << "\t [ headlabel = \"" << LeaderLocalName << "\" , taillabel = \""
+       << itLocalName << "\", fontsize=7, fontcolor=red ]" << std::endl;
+  }
+  return os;
+}
+
+template <class T, class Time>
+std::ostream &SignalPtr<T, Time>::display(std::ostream &os) const {
+  dgTDEBUGIN(25) << SignalBase<Time>::name << this << "||" << isPlugged()
+                 << "||" << signalPtr;
+  { Signal<T, Time>::display(os); }
+
+  if ((isAbstractPluged()) && (!autoref())) {
+    os << " -->-- PLUGGED";
+  } else {
+    if (!isAbstractPluged())
+      os << " UNPLUGGED";
+    else if (autoref())
+      os << " AUTOPLUGGED";
+  }
+
+  dgTDEBUGOUT(25);
+  return os;
+}
+
+template <class T, class Time>
+std::ostream &SignalPtr<T, Time>::displayDependencies(std::ostream &os,
+                                                      const int depth,
+                                                      std::string space,
+                                                      std::string next1,
+                                                      std::string next2) const {
+  dgTDEBUGIN(25);
+  if ((isAbstractPluged()) && (!autoref())) {
+    getAbstractPtr()->displayDependencies(
+        os, depth, space, next1 + "-- " + SignalBase<Time>::name + " -->",
+        next2);
+  } else {
+    SignalBase<Time>::displayDependencies(os, depth, space, next1, next2);
+  }
+  dgTDEBUGOUT(25);
+  return os;
+}
+
+}  // end of namespace dynamicgraph.
+
+#endif  //! DYNAMIC_GRAPH_SIGNAL_PTR_T_CPP

include/dynamic-graph/signal-time-dependent.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_TIME_DEPENDENT_H
+#define DYNAMIC_GRAPH_SIGNAL_TIME_DEPENDENT_H
+#include <dynamic-graph/signal.h>
+#include <dynamic-graph/time-dependency.h>
+
+namespace dynamicgraph {
+/*!  \brief A type of signal that enforces a time dependency between other
+  signals,
+  making sure its inputs are up to date on access, using a incrementing time
+  tick as reference.
+
+  It works this way. For a given SignalTimeDependent S,
+  - the user manually adds dependent signals through the use of the
+  SignalTimeDependent::addDependency function.
+  - On access (calling the signal S SignalTimeDependent::operator()(const Time&)
+  or SignalTimeDependent::access(const Time&) function), if the dependent
+  signals are not up-to-date, i.e. if their [last update] time is less than the
+  current time, their value will be SignalTimeDependent::access ()'ed to bring
+  them up-to-date.
+
+  Thus, the value of dependent signals can be accessed \b quickly and
+  \b repeatedly through the Signal::accessCopy () function.
+
+  An example:
+  \code
+  class MyEntity : public Entity {
+  public:
+  // Some signal dependencies
+  SignalPtr<T,int> dep1, dep2;
+  SignalTimeDependent<T,int> signal;
+
+  MyEntity (const std::string& name)
+    : Entity (name)
+    , signal (
+        // Set the function that computes the signal value
+        boost::bind (&Entity::computeSignal, this, _1, _2),
+        // Declare the dependencies
+        dep1 << dep2,
+        "signalname")
+  {}
+
+   T& computeSignal (T& res, int time)
+   {
+     // The accesses below update the signal if necessary.
+     dep1(time);
+     dep1.access(time);
+     dep1.recompute(time);
+     // If dep1 and dep2 are already up-to-date, for a faster access, use
+     dep1.accessCopy();
+     dep2.accessCopy();
+
+     // Compute res
+     return res;
+   }
+  \endcode
+*/
+template <class T, class Time>
+class SignalTimeDependent : public virtual Signal<T, Time>,
+                            public TimeDependency<Time> {
+  // TimeDependency<Time> timeDependency;
+
+ public:
+  SignalTimeDependent(std::string name = "");
+  SignalTimeDependent(const SignalArray_const<Time> &arr,
+                      std::string name = "");
+  SignalTimeDependent(boost::function2<T &, T &, Time> t,
+                      const SignalArray_const<Time> &sig,
+                      std::string name = "");
+
+  virtual ~SignalTimeDependent() {}
+
+  inline const T &operator()(const Time &t1) { return access(t1); }
+  const T &access(const Time &t1);
+
+  virtual void addDependency(const SignalBase<Time> &signal);
+  virtual void removeDependency(const SignalBase<Time> &signal);
+  virtual void clearDependencies();
+
+  std::ostream &writeGraph(std::ostream &os) const { return os; }
+
+  std::ostream &displayDependencies(std::ostream &os, const int depth = -1,
+                                    std::string space = "",
+                                    std::string next1 = "",
+                                    std::string next2 = "") const {
+    return TimeDependency<Time>::displayDependencies(os, depth, space, next1,
+                                                     next2);
+  }
+
+  virtual bool needUpdate(const Time &t) const;
+  virtual void setPeriodTime(const Time &p);
+  virtual Time getPeriodTime() const;
+};
+
+/* -------------------------------------------- */
+
+template <class T, class Time>
+SignalTimeDependent<T, Time>::SignalTimeDependent(std::string name)
+    : Signal<T, Time>(name), TimeDependency<Time>(this) {}
+
+template <class T, class Time>
+SignalTimeDependent<T, Time>::SignalTimeDependent(
+    const SignalArray_const<Time> &arr, std::string name)
+    : Signal<T, Time>(name), TimeDependency<Time>(this, arr) {}
+
+template <class T, class Time>
+SignalTimeDependent<T, Time>::SignalTimeDependent(
+    boost::function2<T &, T &, Time> t, const SignalArray_const<Time> &sig,
+    std::string name)
+    : Signal<T, Time>(name), TimeDependency<Time>(this, sig) {
+  this->setFunction(t);
+}
+
+template <class T, class Time>
+const T &SignalTimeDependent<T, Time>::access(const Time &t1) {
+  const bool up = TimeDependency<Time>::needUpdate(t1);
+  // SignalBase<Time>::setReady(false);
+
+  /*       std::cout << "Time before: "<< signalTime << " -- "   */
+  /*            << t1<< "  -> Up: "<<up <<std::endl ;   */
+  if (up) {
+    TimeDependency<Time>::lastAskForUpdate = false;
+    const T &Tres = Signal<T, Time>::access(t1);
+    SignalBase<Time>::setReady(false);
+    return Tres;
+  } else {
+    return Signal<T, Time>::accessCopy();
+  }
+}
+
+template <class T, class Time>
+void SignalTimeDependent<T, Time>::addDependency(
+    const SignalBase<Time> &signal) {
+  TimeDependency<Time>::addDependency(signal);
+}
+
+template <class T, class Time>
+void SignalTimeDependent<T, Time>::removeDependency(
+    const SignalBase<Time> &signal) {
+  TimeDependency<Time>::removeDependency(signal);
+}
+
+template <class T, class Time>
+void SignalTimeDependent<T, Time>::clearDependencies() {
+  TimeDependency<Time>::clearDependency();
+}
+
+template <class T, class Time>
+bool SignalTimeDependent<T, Time>::needUpdate(const Time &t) const {
+  return TimeDependency<Time>::needUpdate(t);
+}
+
+template <class T, class Time>
+void SignalTimeDependent<T, Time>::setPeriodTime(const Time &p) {
+  TimeDependency<Time>::setPeriodTime(p);
+}
+template <class T, class Time>
+Time SignalTimeDependent<T, Time>::getPeriodTime() const {
+  return TimeDependency<Time>::getPeriodTime();
+}
+
+}  // end of namespace dynamicgraph
+
+#endif  //! DYNAMIC_GRAPH_SIGNAL_TIME_DEPENDENT_H

src/signal/signal.h → include/dynamic-graph/signal.h

-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- * Copyright Projet JRL-Japan, 2007
- *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- *
- * File:      Signal.h
- * Project:   SOT
- * Author:    Nicolas Mansard
- *
- * Version control
- * ===============
- *
- *  $Id$
- *
- * Description
- * ============
+/*
+ * Copyright 2010,
+ * François Bleibel,
+ * Olivier Stasse,
  *
+ * CNRS/AIST
  *
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-
-
-
+ */
 
 #ifndef __SIGNAL_HH
 #define __SIGNAL_HH
 
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-
-#include <string>
-#include <iostream>
-
 #include <dynamic-graph/exception-signal.h>
 #include <dynamic-graph/signal-base.h>
 
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <string>
 
 #ifdef HAVE_LIBBOOST_THREAD
 #include <boost/thread.hpp>
@@ -45,30 +29,28 @@ namespace dynamicgraph {
   or evaluated as a function.
   See SignalPtr and SignalTimeDependent for other types of signals,
   and SignalArray for a way of grouping them.
- */
-template< class T,class Time >
-class Signal
-: public SignalBase<Time>
-{
- protected:
 
-  enum SignalType
-    {
-      CONSTANT
-      ,REFERENCE
-      ,REFERENCE_NON_CONST
-      ,FUNCTION
-    };
+  There are several ways to specify the value output by a signal:
+  \li using the function setConstant(T) to set the value of the signal to T;
+  \li using the function setReference(mutex, T*) to set the value
+  from a pointer, whose access is restricted by a mutex;
+  \li using the function setFunction(boost::function2) that will be called
+  when the signal's value is accessed.
+*/
+template <class T, class Time>
+class Signal : public SignalBase<Time> {
+ protected:
+  enum SignalType { CONSTANT, REFERENCE, REFERENCE_NON_CONST, FUNCTION };
   static const SignalType SIGNAL_TYPE_DEFAULT = CONSTANT;
 
   SignalType signalType;
-  T Tcopy1,Tcopy2;
-  T* Tcopy;
+  T Tcopy1, Tcopy2;
+  T *Tcopy;
   bool copyInit;
 
-  const T* Treference;
-  T* TreferenceNonConst;
-  boost::function2<T&,T&,Time> Tfunction;
+  const T *Treference;
+  T *TreferenceNonConst;
+  boost::function2<T &, T &, Time> Tfunction;
 
   bool keepReference;
   const static bool KEEP_REFERENCE_DEFAULT = false;
@@ -78,11 +60,11 @@ class Signal
   typedef boost::try_mutex Mutex;
   typedef boost::lock_error MutexError;
 #else
-  typedef int* Mutex;
-  typedef int* MutexError;
+  typedef int *Mutex;
+  typedef int *MutexError;
 #endif
-  
-protected:
+
+ protected:
   Mutex *providerMutex;
   using SignalBase<Time>::signalTime;
 
@@ -90,54 +72,60 @@ protected:
   using SignalBase<Time>::setReady;
 
  public:
-
   /* --- Constructor/destrusctor --- */
-  Signal( std::string name );
-  virtual ~Signal( void ) {}
+  Signal(std::string name);
+  virtual ~Signal() {}
+
+  /* --- Generic In/Out function --- */
+  virtual void get(std::ostream &value) const;
+  virtual void set(std::istringstream &value);
+  virtual void trace(std::ostream &os) const;
 
   /* --- Generic Set function --- */
-  virtual void setConstant( const T& t ); 
-  virtual void setReference( const T* t,Mutex *mutexref=NULL );
-  virtual void setReferenceNonConstant( T* t,Mutex *mutexref=NULL );
-  virtual void setFunction( boost::function2<T&,T&,Time> t,
-			    Mutex *mutexref=NULL);
+  virtual void setConstant(const T &t);
+  virtual void setReference(const T *t, Mutex *mutexref = NULL);
+  virtual void setReferenceNonConstant(T *t, Mutex *mutexref = NULL);
+  virtual void setFunction(boost::function2<T &, T &, Time> t,
+                           Mutex *mutexref = NULL);
 
-  inline bool getKeepReference( void ){ return keepReference; }
-  inline void setKeepReference( const bool& b ){ keepReference=b; }
+  inline bool getKeepReference() { return keepReference; }
+  inline void setKeepReference(const bool &b) { keepReference = b; }
 
   /* --- Signal computation --- */
-  virtual const T& access( const Time & t );
-  virtual inline void recompute( const Time & t ) { access(t); }
-  virtual const T& accessCopy( void ) const;
-  
-  virtual std::ostream& display( std::ostream& os ) const;
+  virtual const T &access(const Time &t);
+  virtual inline void recompute(const Time &t) { access(t); }
+  virtual const T &accessCopy() const;
 
-  /* --- Operators --- */
-  virtual inline const T& operator()( const Time & t ){ return access(t); }
-  virtual Signal<T,Time>& operator= ( const T& t );
-  inline operator const T& ( void ) const { return accessCopy(); }
+  virtual std::ostream &display(std::ostream &os) const;
 
+  /* --- Operators --- */
+  virtual inline const T &operator()(const Time &t) { return access(t); }
+  virtual Signal<T, Time> &operator=(const T &t);
+  inline operator const T &() const { return accessCopy(); }
+  virtual void getClassName(std::string &aClassName) const {
+    aClassName = typeid(this).name();
+  }
 
  public:
-  virtual void checkCompatibility( void ) { throw Tcopy;  }
+  /// 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( void );
-  const T& getTwork( void ) const ;
-  const T& switchTcopy( void );
-
+  const T &setTcopy(const T &t);
+  T &getTwork();
+  const T &getTwork() const;
+  const T &switchTcopy();
 };
 
-} // namespace dynamicgraph
+}  // end of namespace dynamicgraph
 
 #include <dynamic-graph/signal.t.cpp>
 
-#endif // #ifndef __SIGNAL_HH
+#endif  // #ifndef __SIGNAL_HH
 
 /*
  * Local variables:
  * c-basic-offset: 4
  * End:
  */
-

include/dynamic-graph/signal.t.cpp

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_SIGNAL_T_CPP
+#define DYNAMIC_GRAPH_SIGNAL_T_CPP
+#include <dynamic-graph/signal-caster.h>
+#include <dynamic-graph/signal.h>
+
+#undef VP_TEMPLATE_DEBUG_MODE
+#define VP_TEMPLATE_DEBUG_MODE 0
+#include <dynamic-graph/debug.h>
+
+#define __SIGNAL_INIT(name, Tcpy, Tref, TrefNC, mutex)                   \
+  SignalBase<Time>(name), signalType(SIGNAL_TYPE_DEFAULT), Tcopy1(Tcpy), \
+      Tcopy2(Tcpy), Tcopy(&Tcopy1), Treference(Tref),                    \
+      TreferenceNonConst(TrefNC), Tfunction(),                           \
+      keepReference(KEEP_REFERENCE_DEFAULT), providerMutex(mutex)
+
+namespace dynamicgraph {
+
+template <class T, class Time>
+Signal<T, Time>::Signal(std::string name)
+    : __SIGNAL_INIT(name, T(), NULL, NULL, NULL) {
+  return;
+}
+
+/* ------------------------------------------------------------------------ */
+
+template <class T, class Time>
+void Signal<T, Time>::set(std::istringstream &stringValue) {
+  (*this) = signal_io<T>::cast(stringValue);
+}
+
+template <class T, class Time>
+void Signal<T, Time>::get(std::ostream &os) const {
+  signal_io<T>::disp(this->accessCopy(), os);
+}
+
+template <class T, class Time>
+void Signal<T, Time>::trace(std::ostream &os) const {
+  try {
+    signal_io<T>::trace(this->accessCopy(), os);
+  } catch DG_RETHROW catch (...) {
+    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
+                             "TRACE operation not possible with this signal. ",
+                             "(bad cast while getting value from %s).",
+                             SignalBase<Time>::getName().c_str());
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+
+template <class T, class Time>
+const T &Signal<T, Time>::setTcopy(const T &t) {
+  if (Tcopy == &Tcopy1) {
+    Tcopy2 = t;
+    copyInit = true;
+    Tcopy = &Tcopy2;
+    return Tcopy2;
+  } else {
+    Tcopy1 = t;
+    copyInit = true;
+    Tcopy = &Tcopy1;
+    return Tcopy1;
+  }
+}
+
+template <class T, class Time>
+T &Signal<T, Time>::getTwork() {
+  if (Tcopy == &Tcopy1)
+    return Tcopy2;
+  else
+    return Tcopy1;
+}
+
+template <class T, class Time>
+const T &Signal<T, Time>::getTwork() const {
+  if (Tcopy == &Tcopy1)
+    return Tcopy2;
+  else
+    return Tcopy1;
+}
+
+template <class T, class Time>
+const T &Signal<T, Time>::switchTcopy() {
+  if (Tcopy == &Tcopy1) {
+    Tcopy = &Tcopy2;
+    return Tcopy2;
+  } else {
+    Tcopy = &Tcopy1;
+    return Tcopy1;
+  }
+}
+
+template <class T, class Time>
+void Signal<T, Time>::setConstant(const T &t) {
+  signalType = CONSTANT;
+  setTcopy(t);
+  setReady();
+}
+
+template <class T, class Time>
+void Signal<T, Time>::setReference(const T *t, Mutex *mutexref) {
+  signalType = REFERENCE;
+  Treference = t;
+  providerMutex = mutexref;
+  copyInit = false;
+  setReady();
+}
+
+template <class T, class Time>
+void Signal<T, Time>::setReferenceNonConstant(T *t, Mutex *mutexref) {
+  signalType = REFERENCE_NON_CONST;
+  Treference = t;
+  TreferenceNonConst = t;
+  providerMutex = mutexref;
+  copyInit = false;
+  setReady();
+}
+
+template <class T, class Time>
+void Signal<T, Time>::setFunction(boost::function2<T &, T &, Time> t,
+                                  Mutex *mutexref) {
+  signalType = FUNCTION;
+  Tfunction = t;
+  providerMutex = mutexref;
+  copyInit = false;
+  setReady();
+}
+
+template <class T, class Time>
+const T &Signal<T, Time>::accessCopy() const {
+  return *Tcopy;
+}
+
+template <class T, class Time>
+const T &Signal<T, Time>::access(const Time &t) {
+  switch (signalType) {
+    case REFERENCE:
+    case REFERENCE_NON_CONST: {
+      if (NULL == providerMutex) {
+        copyInit = true;
+        signalTime = t;
+        return setTcopy(*Treference);
+      } else {
+        try {
+#ifdef HAVE_LIBBOOST_THREAD
+          boost::try_mutex::scoped_try_lock lock(*providerMutex);
+#endif
+          copyInit = true;
+          signalTime = t;
+          return setTcopy(*Treference);
+        } catch (const MutexError &) {
+          return accessCopy();
+        }
+      }
+
+      break;
+    }
+
+    case FUNCTION: {
+      if (NULL == providerMutex) {
+        signalTime = t;
+        Tfunction(getTwork(), t);
+        copyInit = true;
+        return switchTcopy();
+      } else {
+        try {
+#ifdef HAVE_LIBBOOST_THREAD
+          boost::try_mutex::scoped_try_lock lock(*providerMutex);
+#endif
+          signalTime = t;
+          Tfunction(getTwork(), t);
+          copyInit = true;
+          return switchTcopy();
+        } catch (const MutexError &) {
+          return accessCopy();
+        }
+      }
+      break;
+    }
+    case CONSTANT:
+    default:
+      if (this->getReady()) {
+        setReady(false);
+        this->setTime(t);
+      }
+      return accessCopy();
+  };
+}
+
+template <class T, class Time>
+Signal<T, Time> &Signal<T, Time>::operator=(const T &t) {
+  if (keepReference && (REFERENCE_NON_CONST == signalType) &&
+      (NULL != TreferenceNonConst)) {
+    if (NULL == providerMutex) {
+      setTcopy(t);
+      (*TreferenceNonConst) = t;
+    } else {
+      try {
+#ifdef HAVE_LIBBOOST_THREAD
+        boost::try_mutex::scoped_try_lock lock(*providerMutex);
+#endif
+        setTcopy(t);
+        (*TreferenceNonConst) = t;
+      } catch (const MutexError &) { /* TODO ERROR */
+      }
+    }
+  } else {
+    setConstant(t);
+  }
+  return *this;
+}
+
+template <class T, class Time>
+std::ostream &Signal<T, Time>::display(std::ostream &os) const {
+  os << "Sig:" << this->name << " (Type ";
+  switch (this->signalType) {
+    case Signal<T, Time>::CONSTANT:
+      os << "Cst";
+      break;
+    case Signal<T, Time>::REFERENCE:
+      os << "Ref";
+      break;
+    case Signal<T, Time>::REFERENCE_NON_CONST:
+      os << "RefNonCst";
+      break;
+    case Signal<T, Time>::FUNCTION:
+      os << "Fun";
+      break;
+  }
+  return os << ")";
+}
+
+}  // end of namespace dynamicgraph.
+
+#undef __SIGNAL_INIT
+#endif  //! DYNAMIC_GRAPH_SIGNAL_T_CPP

include/dynamic-graph/time-dependency.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_TIME_DEPENDENCY_H
+#define DYNAMIC_GRAPH_TIME_DEPENDENCY_H
+#include <dynamic-graph/signal-array.h>
+#include <dynamic-graph/signal-base.h>
+
+#include <dynamic-graph/fwd.hh>
+#include <list>
+
+namespace dynamicgraph {
+/** \brief A helper class for setting and specifying dependencies
+    between signals.
+*/
+template <class Time>
+class TimeDependency {
+ public:
+  enum DependencyType { TIME_DEPENDENT, BOOL_DEPENDENT, ALWAYS_READY };
+
+  mutable Time lastAskForUpdate;
+
+ public:
+  SignalBase<Time> &leader;
+
+  typedef std::list<const SignalBase<Time> *> Dependencies;
+  static const DependencyType DEPENDENCY_TYPE_DEFAULT = TIME_DEPENDENT;
+
+  Dependencies dependencies;
+  bool updateFromAllChildren;
+  static const bool ALL_READY_DEFAULT = false;
+
+  DependencyType dependencyType;
+
+  Time periodTime;
+  static const Time PERIOD_TIME_DEFAULT = 1;
+
+ public:
+  TimeDependency(SignalBase<Time> *sig,
+                 const DependencyType dep = DEPENDENCY_TYPE_DEFAULT);
+  TimeDependency(SignalBase<Time> *sig, const SignalArray_const<Time> &arr,
+                 const DependencyType dep = DEPENDENCY_TYPE_DEFAULT);
+  virtual ~TimeDependency() {}
+
+  void addDependencies(const SignalArray_const<Time> &arr);
+  void addDependency(const SignalBase<Time> &sig);
+  void removeDependency(const SignalBase<Time> &sig);
+  void clearDependency();
+
+  virtual std::ostream &writeGraph(std::ostream &os) const;
+  std::ostream &displayDependencies(std::ostream &os, const int depth = -1,
+                                    std::string space = "",
+                                    std::string next1 = "",
+                                    std::string next2 = "") const;
+
+  bool needUpdate(const Time &t1) const;
+
+  void setDependencyType(DependencyType dep) { dependencyType = dep; }
+
+  void setNeedUpdateFromAllChildren(const bool b = true) {
+    updateFromAllChildren = b;
+  }
+  bool getNeedUpdateFromAllChildren() const { return updateFromAllChildren; }
+
+  void setPeriodTime(const Time &p) { periodTime = p; }
+  Time getPeriodTime() const { return periodTime; }
+};
+
+}  // end of namespace dynamicgraph
+
+#include <dynamic-graph/time-dependency.t.cpp>
+#endif  //! DYNAMIC_GRAPH_TIME_DEPENDENCY_H