include/dynamic-graph/command-getter.t.cpp

+//
+// Copyright 2010 CNRS
+//
+// Author: Florent Lamiraux
+//
+
+#ifndef DYNAMIC_GRAPH_COMMAND_GETTER_T_CPP
+#define DYNAMIC_GRAPH_COMMAND_GETTER_T_CPP
+
+#include "dynamic-graph/command-getter.h"
+
+#include <sstream>
+
+namespace dynamicgraph {
+class Entity;
+namespace command {
+
+template <class E, typename T>
+Getter<E, T>::Getter(E &entity, GetterMethod getterMethod,
+                     const std::string &docstring)
+    : Command(entity, std::vector<Value::Type>(), docstring),
+      getterMethod_(getterMethod) {}
+
+template <class E, typename T>
+Value Getter<E, T>::doExecute() {
+  E &entity = static_cast<E &>(owner());
+  T value = (entity.*getterMethod_)();
+  return Value(value);
+}
+}  // namespace command
+}  // namespace dynamicgraph
+
+#endif  // DYNAMIC_GRAPH_COMMAND_GETTER_T_CPP

include/dynamic-graph/command-setter.h

+//
+// Copyright 2010 CNRS
+//
+// Author: Florent Lamiraux
+//
+
+#ifndef DYNAMIC_GRAPH_COMMAND_SETTER_H
+#define DYNAMIC_GRAPH_COMMAND_SETTER_H
+
+#include "dynamic-graph/command.h"
+
+namespace dynamicgraph {
+namespace command {
+
+///
+/// Command that calls a parameter setter function
+///
+/// This class is templated by a type E deriving from entity and
+/// a type T of data.
+///
+/// Let us assume that class E has a private member of type T and a
+/// public setter function for this member:
+/// \code
+/// class E : public Entity
+/// {
+/// public:
+///   E (const std::string& inName) : Entity(inName) {}
+///   void setParameter(const T& parameter) {parameter_ = parameter;}
+/// private:
+///   T parameter_;
+/// };
+/// \endcode
+/// Then the command defined by:
+/// \code
+/// E entity("MyEntity");
+/// Setter<E,T> command(entity, &E::getParameter)
+/// \endcode
+/// sets the value of <c>entity.parameter_</c> upon invocation.
+///
+/// \note
+/// \li T should be a type supported by class Value,
+/// \li prototype of E::setParameter should be exactly as specified in this
+/// example.
+template <class E, typename T>
+class Setter : public Command {
+ public:
+  /// Pointer to method that sets parameter of type T
+  typedef void (E::*SetterMethod)(const T &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};
+}  // namespace command
+}  // namespace dynamicgraph
+
+#include "dynamic-graph/command-setter.t.cpp"
+#endif  // DYNAMIC_GRAPH_COMMAND_SETTER_H

include/dynamic-graph/command-setter.t.cpp

+//
+// Copyright 2010 CNRS
+//
+// Author: Florent Lamiraux
+//
+
+#ifndef DYNAMIC_GRAPH_COMMAND_SETTER_T_CPP
+#define DYNAMIC_GRAPH_COMMAND_SETTER_T_CPP
+
+#include "dynamic-graph/command-setter.h"
+
+#include <boost/assign/list_of.hpp>
+#include <sstream>
+
+#include "dynamic-graph/linear-algebra.h"
+
+namespace dynamicgraph {
+class Entity;
+namespace command {
+
+//
+// Template specialization: bool
+//
+template <class E>
+class Setter<E, bool> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type bool
+  typedef void (E::*SetterMethod)(const bool &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, bool>::Setter(E &entity, SetterMethod setterMethod,
+                        const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::BOOL), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, bool>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  bool value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: unsigned
+//
+template <class E>
+class Setter<E, unsigned> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type unsigned
+  typedef void (E::*SetterMethod)(const unsigned &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, unsigned>::Setter(E &entity, SetterMethod setterMethod,
+                            const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::UNSIGNED), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, unsigned>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  unsigned value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: int
+//
+template <class E>
+class Setter<E, int> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type int
+  typedef void (E::*SetterMethod)(const int &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, int>::Setter(E &entity, SetterMethod setterMethod,
+                       const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::INT), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, int>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  int value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: float
+//
+template <class E>
+class Setter<E, float> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type float
+  typedef void (E::*SetterMethod)(const float &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, float>::Setter(E &entity, SetterMethod setterMethod,
+                         const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::FLOAT), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, float>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  float value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: double
+//
+template <class E>
+class Setter<E, double> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type double
+  typedef void (E::*SetterMethod)(const double &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, double>::Setter(E &entity, SetterMethod setterMethod,
+                          const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::DOUBLE), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, double>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  double value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: std::string
+//
+template <class E>
+class Setter<E, std::string> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type std::string
+  typedef void (E::*SetterMethod)(const std::string &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, std::string>::Setter(E &entity, SetterMethod setterMethod,
+                               const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::STRING), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, std::string>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  std::string value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: Vector
+//
+template <class E>
+class Setter<E, Vector> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type Vector
+  typedef void (E::*SetterMethod)(const Vector &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, Vector>::Setter(E &entity, SetterMethod setterMethod,
+                          const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::VECTOR), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, Vector>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  Vector value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+//
+// Template specialization: Matrix
+//
+template <class E>
+class Setter<E, Matrix> : public Command {
+ public:
+  /// Pointer to method that sets parameter of type Matrix
+  typedef void (E::*SetterMethod)(const Matrix &);
+  /// Constructor
+  Setter(E &entity, SetterMethod setterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  SetterMethod setterMethod_;
+};  // Class Setter
+
+template <class E>
+Setter<E, Matrix>::Setter(E &entity, SetterMethod setterMethod,
+                          const std::string &docString)
+    : Command(entity, boost::assign::list_of(Value::MATRIX), docString),
+      setterMethod_(setterMethod) {}
+
+template <class E>
+Value Setter<E, Matrix>::doExecute() {
+  const std::vector<Value> &values = getParameterValues();
+  // Get parameter
+  Matrix value = values[0].value();
+  E &entity = static_cast<E &>(owner());
+  (entity.*setterMethod_)(value);
+  return Value();
+}
+
+}  // namespace command
+}  // namespace dynamicgraph
+
+#endif  // DYNAMIC_GRAPH_COMMAND_SETTER_T_CPP

include/dynamic-graph/command.h

+//
+// Copyright 2010 CNRS
+//
+// Author: Florent Lamiraux
+//
+
+#ifndef DYNAMIC_GRAPH_COMMAND_H
+#define DYNAMIC_GRAPH_COMMAND_H
+
+#include <vector>
+
+#include "dynamic-graph/dynamic-graph-api.h"
+#include "dynamic-graph/value.h"
+
+namespace dynamicgraph {
+class Entity;
+namespace command {
+/// \ingroup dgraph
+/// Abstract class for entity commands
+///
+/// This class provide a mean to control entities from external
+/// python script.
+///
+/// A command
+/// \li is owned by an entity,
+/// \li takes parameters of type Value,
+/// \li return an instance of Value when calling Command::execute()
+///
+/// At construction, the prototype of the command is defined by providing
+/// a vector of Value::Type.
+///
+/// Parameters are set by calling Command::setParameterValues with a
+/// vector of Values the types of which should fit the vector specified
+/// at construction.
+class DYNAMIC_GRAPH_DLLAPI Command {
+ public:
+  virtual ~Command();
+  /// Store the owner entity and a vector of value types
+  /// \param entity reference to Entity owning this command.
+  /// \param valueTypes vector specifying the number and types of parameters
+  /// \param docstring documentation of the command
+  Command(Entity &entity, const std::vector<Value::Type> &valueTypes,
+          const std::string &docstring);
+  /// Return the value type of all parameters
+  const std::vector<Value::Type> &valueTypes() const;
+  /// Set parameter values
+  void setParameterValues(const std::vector<Value> &values);
+  /// Get parameter values
+  const std::vector<Value> &getParameterValues() const;
+  /// Execute the command after checking parameters
+  Value execute();
+  /// Get a reference to the Entity owning this command
+  Entity &owner();
+  /// Get documentation string
+  std::string getDocstring() const;
+
+ protected:
+  /// Specific action performed by the command
+  virtual Value doExecute() = 0;
+
+ private:
+  Entity &owner_;
+  std::vector<Value::Type> valueTypeVector_;
+  std::vector<Value> valueVector_;
+  std::string docstring_;
+
+ public:
+  static const std::vector<Value::Type> EMPTY_ARG;
+};
+}  // namespace command
+}  // namespace dynamicgraph
+
+#endif  // DYNAMIC_GRAPH_COMMAND_H

include/dynamic-graph/contiifstream.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __CONTIIFSTREAM_HH__
-#define __CONTIIFSTREAM_HH__
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <list>
-
-#include <dynamic-graph/interpreter.h>
-#ifndef WIN32
-#include <pthread.h>
-#endif
-/* --------------------------------------------------------------------- */
-/* --- API ------------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-#if defined (WIN32)
-#  if defined (contiifstream_EXPORTS)
-#    define DYNAMICGRAPHCONTIIFSTREAM_EXPORT __declspec(dllexport)
-#  else
-#    define DYNAMICGRAPHCONTIIFSTREAM_EXPORT __declspec(dllimport)
-#  endif
-#else
-#  define DYNAMICGRAPHCONTIIFSTREAM_EXPORT
-#endif
-
-namespace dynamicgraph {
-  /* --------------------------------------------------------------------- */
-  /* --- CLASS ----------------------------------------------------------- */
-  /* --------------------------------------------------------------------- */
-  class DYNAMICGRAPHCONTIIFSTREAM_EXPORT Contiifstream
-  {
-  protected:
-    std::string filename;
-    unsigned int cursor;
-    static const unsigned int BUFFER_SIZE = 256;
-    char buffer[BUFFER_SIZE];
-    std::list< std::string > reader;
-    bool first;
-
-  public: /* --- Constructor --- */
-    Contiifstream( const std::string& n="" );
-    ~Contiifstream( void );
-    void open( const std::string& n ) { filename=n; cursor=0; }
-
-  public: /* --- READ FILE --- */
-    bool loop( void );
-
-  public: /* --- READ LIST --- */
-    inline bool ready( void ) { return 0<reader.size();}
-    std::string next( void ) ;
-
-
-  };
-} // namespace dynamicgraph
-
-#endif /* #ifndef __CONTIIFSTREAM_HH__ */
-
-
-
-

include/dynamic-graph/debug.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * Macro de trace et de debugage
- *
- *   - TRACAGE:    TRACE et ERROR_TRACE fonctionnent comme des printf
- * avec retour chariot en fin de fonction.
- *                 CERROR et CTRACE fonctionnent comme les flux de sortie
- * C++ cout et cerr.
- *   - DEBUGAGE:   DEBUG_TRACE(niv,  et DERROR_TRACE(niv, fonctionnent
- * comme des printf, n'imprimant que si le niveau de trace 'niv' est
- * superieur au mode de debugage VP_DEBUG_MODE.
- *                 CDEBUG(niv) fonctionne comme le flux de sortie C++ cout.
- *                 DEBUG_ENABLE(niv) vaut 1 ssi le niveau de tracage 'niv'
- * est superieur au  mode de debugage DEBUG_MODE. Il vaut 0 sinon.
- *   - PROG DEFENSIVE: DEFENSIF(a) vaut a ssi le mode defensif est active,
- * et vaut 0 sinon.
- *
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-
-
-
-
-#ifndef __DEBUG_HH
-#define __DEBUG_HH
-
-#include <stdio.h>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <stdarg.h>
-#include <dynamic-graph/dynamic-graph-api.h>
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
 
- 
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
+#ifndef DYNAMIC_GRAPH_DEBUG_HH
+#define DYNAMIC_GRAPH_DEBUG_HH
+#include <dynamic-graph/dynamic-graph-api.h>
 
-/* -------------------------------------------------------------------------- */
+#include <cstdarg>
+#include <cstdio>
+#include <dynamic-graph/fwd.hh>
+#include <fstream>
+#include <sstream>
 
 #ifndef VP_DEBUG_MODE
 #define VP_DEBUG_MODE 0
-#endif 
+#endif  //! VP_DEBUG_MODE
+
 #ifndef VP_TEMPLATE_DEBUG_MODE
 #define VP_TEMPLATE_DEBUG_MODE 0
-#endif
+#endif  //! VP_TEMPLATE_DEBUG_MODE
 
-#define DG_COMMON_TRACES do {  \
-		    va_list arg; \
-		    va_start(arg,format); \
-		    vsnprintf( charbuffer,SIZE,format,arg ); \
-		    va_end(arg); \
-		    outputbuffer << tmpbuffer.str() << charbuffer <<std::endl; \
-		} while(0)
+#define DG_COMMON_TRACES                                        \
+  do {                                                          \
+    va_list arg;                                                \
+    va_start(arg, format);                                      \
+    vsnprintf(charbuffer, SIZE, format, arg);                   \
+    va_end(arg);                                                \
+    outputbuffer << tmpbuffer.str() << charbuffer << std::endl; \
+  } while (0)
 
 namespace dynamicgraph {
-
-class DYNAMICGRAPH_EXPORT DebugTrace
-{
+/// \ingroup debug
+///
+/// \brief Logging class.
+///
+/// This class should never be used directly, please use the
+/// debugging macro instead.
+class DYNAMIC_GRAPH_DLLAPI DebugTrace {
  public:
-    static const int SIZE = 512;
+  static const int SIZE = 512;
+
+  std::stringstream tmpbuffer;
+  std::ostream &outputbuffer;
+  char charbuffer[SIZE + 1];
+  int traceLevel;
+  int traceLevelTemplate;
+
+  DebugTrace(std::ostream &os) : outputbuffer(os) {}
+
+  inline void trace(const int level, const char *format, ...) {
+    if (level <= traceLevel) DG_COMMON_TRACES;
+    tmpbuffer.str("");
+  }
+
+  inline void trace(const char *format, ...) {
+    DG_COMMON_TRACES;
+    tmpbuffer.str("");
+  }
+
+  inline void trace(const int level = -1) {
+    if (level <= traceLevel) {
+      outputbuffer << tmpbuffer.str();
+      tmpbuffer.str("");
+    }
+  }
+
+  inline void traceTemplate(const int level, const char *format, ...) {
+    if (level <= traceLevelTemplate) DG_COMMON_TRACES;
+    tmpbuffer.str("");
+  }
+
+  inline void traceTemplate(const char *format, ...) {
+    DG_COMMON_TRACES;
+    tmpbuffer.str("");
+  }
+
+  inline DebugTrace &pre(const std::ostream &) { return *this; }
+
+  inline DebugTrace &pre(const std::ostream &, int level) {
+    traceLevel = level;
+    return *this;
+  }
+
+  static const char *DEBUG_FILENAME_DEFAULT;
+  static void openFile(const char *filename = DEBUG_FILENAME_DEFAULT);
+  static void closeFile(const char *filename = DEBUG_FILENAME_DEFAULT);
+};
 
-    std::stringstream tmpbuffer;
-    std::ostream& outputbuffer;
-    char charbuffer[SIZE+1];
-    int traceLevel;
-    int traceLevelTemplate; 
+DYNAMIC_GRAPH_DLLAPI extern DebugTrace dgDEBUGFLOW;
+DYNAMIC_GRAPH_DLLAPI extern DebugTrace dgERRORFLOW;
+}  // end of namespace dynamicgraph
 
-    DebugTrace( std::ostream& os ): outputbuffer(os) {}
+#ifdef VP_DEBUG
 
-    inline void trace( const int level,const char* format,...)
-	{ if( level<=traceLevel ) DG_COMMON_TRACES; tmpbuffer.str(""); }
-    inline void trace( const char* format,...){ DG_COMMON_TRACES;  tmpbuffer.str(""); }
-    inline void trace( const int level=-1 ) 
-	{ if( level<=traceLevel ) outputbuffer << tmpbuffer.str(); tmpbuffer.str("");  }
+#define dgPREDEBUG __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") :"
+#define dgPREERROR \
+  "\t!! " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") :"
+
+#define dgDEBUG(level)                                               \
+  if ((level > VP_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
+    ;                                                                \
+  else                                                               \
+    dgDEBUGFLOW.outputbuffer << dgPREDEBUG
+
+#define dgDEBUGMUTE(level)                                           \
+  if ((level > VP_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
+    ;                                                                \
+  else                                                               \
+    dgDEBUGFLOW.outputbuffer
+
+#define dgERROR                         \
+  if (!dgDEBUGFLOW.outputbuffer.good()) \
+    ;                                   \
+  else                                  \
+    dgERRORFLOW.outputbuffer << dgPREERROR
+
+#define dgDEBUGF                        \
+  if (!dgDEBUGFLOW.outputbuffer.good()) \
+    ;                                   \
+  else                                  \
+    dgDEBUGFLOW.pre(dgDEBUGFLOW.tmpbuffer << dgPREDEBUG, VP_DEBUG_MODE).trace
+
+#define dgERRORF                        \
+  if (!dgDEBUGFLOW.outputbuffer.good()) \
+    ;                                   \
+  else                                  \
+    dgERRORFLOW.pre(dgERRORFLOW.tmpbuffer << dgPREERROR).trace
 
-    inline void traceTemplate( const int level,const char* format,...)
-	{ if( level<=traceLevelTemplate ) DG_COMMON_TRACES; tmpbuffer.str(""); }
-    inline void traceTemplate( const char* format,...)
-	{ DG_COMMON_TRACES; tmpbuffer.str("");  }
+// TEMPLATE
+#define dgTDEBUG(level)                                                       \
+  if ((level > VP_TEMPLATE_DEBUG_MODE) || (!dgDEBUGFLOW.outputbuffer.good())) \
+    ;                                                                         \
+  else                                                                        \
+    dgDEBUGFLOW.outputbuffer << dgPREDEBUG
 
-    inline DebugTrace& pre( const std::ostream& dummy ) { return *this; }
-    inline DebugTrace& pre( const std::ostream& dummy,int level )
-	{ traceLevel = level; return *this; }
-/*     inline DebugTrace& preTemplate( const std::ostream& dummy,int level )  */
-/* 	{ traceLevelTemplate = level; return *this; } */
+#define dgTDEBUGF                                                         \
+  if (!dgDEBUGFLOW.outputbuffer.good())                                   \
+    ;                                                                     \
+  else                                                                    \
+    dgDEBUGFLOW                                                           \
+        .pre(dgDEBUGFLOW.tmpbuffer << dgPREDEBUG, VP_TEMPLATE_DEBUG_MODE) \
+        .trace
 
+inline bool dgDEBUG_ENABLE(const int &level) { return level <= VP_DEBUG_MODE; }
 
-    static const char * DEBUG_FILENAME_DEFAULT;
-    static void openFile( const char * filename = DEBUG_FILENAME_DEFAULT );
-    static void closeFile( const char * filename = DEBUG_FILENAME_DEFAULT );
+inline bool dgTDEBUG_ENABLE(const int &level) {
+  return level <= VP_TEMPLATE_DEBUG_MODE;
+}
 
-};
+#else  // VP_DEBUG
 
-DYNAMICGRAPH_EXPORT extern DebugTrace dgDEBUGFLOW;
-DYNAMICGRAPH_EXPORT extern DebugTrace dgERRORFLOW;
+#define dgPREERROR \
+  "\t!! " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") :"
 
-} // namespace dynamicgraph
+#define dgDEBUG(level) \
+  if (1)               \
+    ;                  \
+  else                 \
+    ::dynamicgraph::__null_stream()
+
+#define dgDEBUGMUTE \
+  (level) if (1);   \
+  else ::dynamicgraph::__null_stream()
+
+#define dgERROR dgERRORFLOW.outputbuffer << dgPREERROR
+
+inline void dgDEBUGF(const int, const char *, ...) { return; }
+
+inline void dgDEBUGF(const char *, ...) { return; }
+
+inline void dgERRORF(const int, const char *, ...) { return; }
+
+inline void dgERRORF(const char *, ...) { return; }
+
+namespace dynamicgraph {
+inline std::ostream &__null_stream() {
+  // This function should never be called. With -O3,
+  // it should not appear in the generated binary.
+  static std::ostream os(NULL);
+  return os;
+}
+}  // namespace dynamicgraph
 
-#ifdef VP_DEBUG
-#define dgPREDEBUG  __FILE__ << ": " <<__FUNCTION__  \
-                              << "(#" << __LINE__ << ") :" 
-#define dgPREERROR  "\t!! "<<__FILE__ << ": " <<__FUNCTION__  \
-                            << "(#" << __LINE__ << ") :" 
-
-#  define dgDEBUG(level) if( (level>VP_DEBUG_MODE)||(!dgDEBUGFLOW.outputbuffer.good()) ) ;\
-    else dgDEBUGFLOW.outputbuffer << dgPREDEBUG
-#  define dgDEBUGMUTE(level) if( (level>VP_DEBUG_MODE)||(!dgDEBUGFLOW.outputbuffer.good()) ) ;\
-    else dgDEBUGFLOW.outputbuffer
-#  define dgERROR  if(!dgDEBUGFLOW.outputbuffer.good()); else dgERRORFLOW.outputbuffer << dgPREERROR
-#  define dgDEBUGF if(!dgDEBUGFLOW.outputbuffer.good()); else dgDEBUGFLOW.pre(dgDEBUGFLOW.tmpbuffer<<dgPREDEBUG,VP_DEBUG_MODE).trace
-#  define dgERRORF if(!dgDEBUGFLOW.outputbuffer.good()); else dgERRORFLOW.pre(dgERRORFLOW.tmpbuffer<<dgPREERROR).trace
-// TEMPLATE
-#  define dgTDEBUG(level) if( (level>VP_TEMPLATE_DEBUG_MODE)||(!dgDEBUGFLOW.outputbuffer.good()) ) ;\
-    else dgDEBUGFLOW.outputbuffer << dgPREDEBUG
-#  define dgTDEBUGF  if(!dgDEBUGFLOW.outputbuffer.good()); else dgDEBUGFLOW.pre(dgDEBUGFLOW.tmpbuffer<<dgPREDEBUG,VP_TEMPLATE_DEBUG_MODE).trace
-inline bool dgDEBUG_ENABLE( const int & level ) { return level<=VP_DEBUG_MODE; }
-inline bool dgTDEBUG_ENABLE( const int & level ) { return level<=VP_TEMPLATE_DEBUG_MODE; }
-
-/* -------------------------------------------------------------------------- */
-#else // #ifdef VP_DEBUG
-#define dgPREERROR  "\t!! "<<__FILE__ << ": " <<__FUNCTION__  \
-                            << "(#" << __LINE__ << ") :" 
-#  define dgDEBUG(level) if( 1 ) ; else std::cout
-#  define dgDEBUGMUTE(level) if( 1 ) ; else std::cout
-#  define dgERROR dgERRORFLOW.outputbuffer << dgPREERROR
-inline void dgDEBUGF( const int level,const char* format,...) { return; }
-inline void dgDEBUGF( const char* format,...) { return; }
-inline void dgERRORF( const int level,const char* format,...) { return; }
-inline void dgERRORF( const char* format,...) { return; }
 // TEMPLATE
-#  define dgTDEBUG(level) if( 1 ) ; else std::cout
-inline void dgTDEBUGF( const int level,const char* format,...) { return; }
-inline void dgTDEBUGF( const char* format,...) { return; }
+#define dgTDEBUG(level) \
+  if (1)                \
+    ;                   \
+  else                  \
+    ::dynamicgraph::__null_stream()
+
+inline void dgTDEBUGF(const int, const char *, ...) { return; }
+
+inline void dgTDEBUGF(const char *, ...) { return; }
+
 #define dgDEBUG_ENABLE(level) false
 #define dgTDEBUG_ENABLE(level) false
 
-#endif // #ifdef VP_DEBUG
-/* -------------------------------------------------------------------------- */
+#endif  //! VP_DEBUG
 
 #define dgDEBUGIN(level) dgDEBUG(level) << "# In {" << std::endl
+
 #define dgDEBUGOUT(level) dgDEBUG(level) << "# Out }" << std::endl
+
 #define dgDEBUGINOUT(level) dgDEBUG(level) << "# In/Out { }" << std::endl
 
 #define dgTDEBUGIN(level) dgTDEBUG(level) << "# In {" << std::endl
-#define dgTDEBUGOUT(level) dgTDEBUG(level) << "# Out }" << std::endl
-#define dgTDEBUGINOUT(level) dgTDEBUG(level) << "# In/Out { }" << std::endl
 
+#define dgTDEBUGOUT(level) dgTDEBUG(level) << "# Out }" << std::endl
 
-#endif /* #ifdef __VS_DEBUG_HH */
+#define dgTDEBUGINOUT(level) dgTDEBUG(level) << "# In/Out { }" << std::endl
 
-/*
- * Local variables:
- * c-basic-offset: 4
- * End:
- */
+#endif  //! DYNAMIC_GRAPH_DEBUG_HH

include/dynamic-graph/dynamic-graph-api.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
 
-#ifndef DYNAMICGRAPH_API_H
-#define DYNAMICGRAPH_API_H
-
-#if defined (WIN32)
-#  ifdef dynamic_graph_EXPORTS
-#    define DYNAMICGRAPH_EXPORT __declspec(dllexport)
-#  else
-#    define DYNAMICGRAPH_EXPORT __declspec(dllimport)
-#  endif
-#else
-#  define DYNAMICGRAPH_EXPORT
-#endif
-
-#endif
+#ifndef DYNAMIC_GRAPH_API_H
+#define DYNAMIC_GRAPH_API_H
+#include <dynamic-graph/config.hh>
+#endif  //! DYNAMIC_GRAPH_API_H

include/dynamic-graph/eigen-io.h

+//
+// Copyright 2016 CNRS
+//
+// Author: Rohan Budhiraja
+//
+
+#ifndef DYNAMIC_GRAPH_EIGEN_IO_H
+#define DYNAMIC_GRAPH_EIGEN_IO_H
+
+#include <dynamic-graph/exception-signal.h>
+#include <dynamic-graph/linear-algebra.h>
+
+#include <Eigen/Geometry>
+#include <boost/format.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+using dynamicgraph::ExceptionSignal;
+
+// TODO: Eigen 3.3 onwards has a global Eigen::Index definition.
+// If Eigen version is updated, use Eigen::Index instead of this macro.
+
+/* \brief Eigen Vector input from istream
+ *
+ * Input Vector format: [N](val1,val2,val3,...,valN)
+ * e.g. [5](1,23,32.2,12.12,32)
+ */
+namespace Eigen {
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE eigen_index;
+
+inline std::istringstream &operator>>(std::istringstream &iss,
+                                      dynamicgraph::Vector &inst) {
+  unsigned int _size;
+  double _dbl_val;
+  char _ch;
+  boost::format fmt(
+      "Failed to enter %s as vector."
+      " Reenter as [N](val1,val2,val3,...,valN)");
+  fmt % iss.str();
+  if (iss >> _ch && _ch != '[') {
+    throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+  } else {
+    if (iss >> _size && !iss.fail()) {
+      inst.resize(_size);
+    } else
+      throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+    if (iss >> _ch && _ch != ']')
+      throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+    else {
+      if (iss >> _ch && _ch != '(')
+        throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+      else {
+        for (unsigned int i = 0; i < _size; i++) {
+          iss >> _dbl_val;
+          if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
+          inst(i) = _dbl_val;
+        }
+        if (iss >> _ch && _ch != ')')
+          throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+      }
+    }
+  }
+  return iss;
+}
+
+/* \brief Eigen Matrix input from istream
+ *
+ * Matrix format: [M,N]((val11,val12,val13,...,val1N),...,
+ * (valM1,valM2,...,valMN))
+ * e.g. [2,5]((1 23 32.2 12.12 32),(2 32 23 92.01 19.2))
+ */
+
+template <typename Derived>
+inline std::istringstream &operator>>(std::istringstream &iss,
+                                      DenseBase<Derived> &inst) {
+  unsigned int _colsize;
+  unsigned int _rowsize;
+  double _dbl_val;
+  char _ch;
+  boost::format fmt(
+      "Failed to enter %s as matrix. Reenter as "
+      "((val11,val12,val13,...,val1N),"
+      "...,(valM1,valM2,...,valMN))");
+  MatrixXd _tmp_matrix;
+  fmt % iss.str();
+  if (iss >> _ch && _ch != '[') {
+    throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+  } else {
+    iss >> _rowsize;
+    if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
+    iss >> _colsize;
+    if (iss.fail())
+      throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+    else {
+      _tmp_matrix.resize(_rowsize, _colsize);
+      if (iss >> _ch && _ch != ']')
+        throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+      else {
+        if (iss >> _ch && _ch != '(')
+          throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+        else {
+          for (unsigned int j = 0; j < _rowsize; j++) {
+            if (iss >> _ch && _ch != '(')
+              throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+            for (unsigned int i = 0; i < _colsize; i++) {
+              iss >> _dbl_val;
+              if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
+              _tmp_matrix(j, i) = _dbl_val;
+            }
+            if (iss >> _ch && _ch != ')')
+              throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+            if (iss.peek() == ',' || iss.peek() == ' ') iss.ignore();
+          }
+          if (iss >> _ch && _ch != ')')
+            throw ExceptionSignal(ExceptionSignal::GENERIC, fmt.str());
+        }
+      }
+    }
+  }
+  inst = _tmp_matrix;
+  return iss;
+}
+
+inline std::istringstream &operator>>(std::istringstream &iss,
+                                      Transform<double, 3, Affine> &inst) {
+  MatrixXd M;
+  iss >> M;
+  inst.matrix() = M;
+  return iss;
+}
+
+/* \brief Eigen Homogeneous Matrix output
+ *
+ * Matrix format: [M,N]((val11,val12,val13,...,val1N),...,
+ * (valM1,valM2,...,valMN))
+ * e.g. [2,5]((1 23 32.2 12.12 32),(2 32 23 92.01 19.2))
+ */
+
+inline std::ostream &operator<<(std::ostream &os,
+                                Transform<double, 3, Affine> MH) {
+  IOFormat boostFmt(StreamPrecision, DontAlignCols, ",", ",", "(", ")", "(",
+                    ")");
+
+  os << "[4,4]" << MH.matrix().format(boostFmt);
+  return os;
+}
+
+inline std::ostream &operator<<(std::ostream &os, AngleAxisd quat) {
+  VectorXd v(4);
+  v(0) = quat.angle();
+  v.tail<3>() = quat.axis();
+  os << v;
+  return os;
+}
+
+inline std::istringstream &operator>>(std::istringstream &iss,
+                                      AngleAxisd &inst) {
+  VectorXd v(4);
+  iss >> v;
+  inst.angle() = v(0);
+  inst.axis() = v.tail<3>();
+  return iss;
+}
+
+}  // namespace Eigen
+
+#endif  // DYNAMIC_GRAPH_EIGEN_IO_H

include/dynamic-graph/entity-helper.h

+/*
+ * Copyright 2011, Nicolas Mansard, LAAS-CNRS
+ *
+ */
+
+#ifndef __sot_core_entity_helper_H__
+#define __sot_core_entity_helper_H__
+
+namespace dynamicgraph {
+
+template <typename Ent>
+struct EntityHelper {
+  typedef Ent EntityClassName;
+  // static const std::string CLASS_NAME; TO BE ADDED IN DG DIRECTLY
+};
+
+}  // namespace dynamicgraph
+
+#endif  // __sot_core_entity_helper_H__

include/dynamic-graph/entity.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __ENTITY_HH__
-#define __ENTITY_HH__
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/* DYNAMIC-GRAPH */
-#include <dynamic-graph/signal-base.h>
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_ENTITY_H
+#define DYNAMIC_GRAPH_ENTITY_H
+#include <dynamic-graph/dynamic-graph-api.h>
 #include <dynamic-graph/exception-factory.h>
+#include <dynamic-graph/logger.h>
 #include <dynamic-graph/signal-array.h>
-#include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/signal-base.h>
 
-/* --- STD --- */
-#include <string>
+#include <boost/noncopyable.hpp>
+#include <dynamic-graph/fwd.hh>
+#include <iosfwd>
 #include <map>
 #include <sstream>
+#include <string>
 
-/* --- BOOST --- */
-#include <boost/noncopyable.hpp>
+/// \brief Helper macro for entity declaration.
+///
+/// This macro should be called in the declaration of all entities.
+/// Example:
+/// <code>
+/// class A : public dynamicgraph::entity
+/// {
+///   DYNAMIC_GRAPH_ENTITY_DECL();
+///
+///   public:
+//      // your class here
+/// };
+/// </code>
+///
+/// Caution: you *MUST* call DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN in the
+/// associated source file to ensure that the attributes generated by
+/// this macro are correctly initialized.
+#define DYNAMIC_GRAPH_ENTITY_DECL()                                      \
+ public:                                                                 \
+  virtual const std::string &getClassName() const { return CLASS_NAME; } \
+  static const std::string CLASS_NAME
 
-/* NAMESPACE */
 namespace dynamicgraph {
-
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-/*! \ingroup dgraph
-  \brief This class represents an entity, i.e. a generic
-  computational unit that provides input and output signals.
-
-  These signals link the entities together to form a complete computation graph.
-  To declare a new entity, please see the DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN macro
-  in g_factory.h.
-  A command-line interface provided by the entity can be used by a sot shell to
-  call methods from entities and display the result of their execution.
-  Classes that derive from Entity can customize the command-line by overriding commandLine().
- */
-class DYNAMICGRAPH_EXPORT Entity
-: private boost::noncopyable
-{
+/// \ingroup dgraph
+///
+/// \brief This class represents an entity, i.e. a generic
+/// computational unit that provides input and output signals.
+///
+/// These signals link the entities together to form a complete
+/// computation graph.  To declare a new entity, please see the
+/// 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<const std::string, command::Command *> CommandMap_t;
+
+  explicit Entity(const std::string &name);
+  virtual ~Entity();
+
+  const std::string &getName() const { return name; }
+  virtual const std::string &getClassName() const {
+    static std::string ret("Entity");
+    return ret;
+  }
+  /** \brief Returns the Entity documentation
+      \return The documentation is provided as std::string object.
+   */
+  virtual std::string getDocString() const;
+
+  /** \brief Test if a signal of name signame is present.
+      \return True if the signal is present, False otherwise
+   */
+  bool hasSignal(const std::string &signame) const;
+
+  /** \brief Provides a reference to the signal named signalName.
+      \param signalName: Name of the signal
+      \return A reference to the signal with a temporal dependency.
+   */
+  SignalBase<int> &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;
+
+  /** \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.
+      \returns The output stream given in parameter.
+  */
+  std::ostream &displaySignalList(std::ostream &os) const;
+
+  /** \brief This method is used to write down in os the edges of the graph
+      by calling the signals writeGraph method.
+      \param os: The output stream where to write the informations.
+      \return os: The output stream.
+   */
+  virtual std::ostream &writeGraph(std::ostream &os) const;
+
+  /** \brief This method is used write in the output stream os the
+      signals names and the commands of the entity.
+      \param os: The output stream where to write the list of objects
+      related to the entity.
+   */
+  virtual std::ostream &writeCompletionList(std::ostream &os) const;
+
+  /** \brief Display information on the entity inside the output stream os.
+   */
+  virtual void display(std::ostream &os) const;
+
+  virtual SignalBase<int> *test() { return 0; }
+
+  virtual void test2(SignalBase<int> *) { return; }
+
+  const std::string &getCommandList() const;
+
+  /** \brief Provides the std::map where all the commands are registered
+      \returns A map of pointers towards Command objects
+  */
+  CommandMap_t getNewStyleCommandMap();
+  /** \brief Provides the pointer towards the Command object cmdName.
+      \param cmdName: Name of the command
+  */
+  command::Command *getNewStyleCommand(const std::string &cmdName);
+
+  /** \brief Provides a map of all the signals.
+      \returns A copy of the map with all the pointers towards
+      the entity signals.
+   */
+  SignalMap getSignalMap() const;
+
+  /// \name Logger related methods
+  /// \{
+
+  Logger &logger() { return logger_; };
+  Logger const &logger() const { return logger_; };
+
+  /// \brief Send messages \c msg with level \c t.
+  /// Add string file and line to message.
+  void sendMsg(const std::string &msg, MsgType t = MSG_TYPE_INFO,
+               const std::string &lineId = "");
+
+  /// \brief Specify the verbosity level of the logger.
+  void setLoggerVerbosityLevel(LoggerVerbosity lv) { logger_.setVerbosity(lv); }
+
+  /// \brief Get the logger's verbosity level.
+  LoggerVerbosity getLoggerVerbosityLevel() { return logger_.getVerbosity(); }
+
+  /// \brief Set the time sample.
+  bool setTimeSample(double t) { return logger_.setTimeSample(t); }
+
+  /// \brief Get the time sample.
+  double getTimeSample() { return logger_.getTimeSample(); }
+
+  /// \brief Set the period of the stream period
+  bool setStreamPrintPeriod(double t) {
+    return logger_.setStreamPrintPeriod(t);
+  }
+
+  /// \brief Get the period of the stream period
+  double getStreamPrintPeriod() { return logger_.getStreamPrintPeriod(); }
+
+  /// \}
 
  protected:
-  std::string name;
+  void addCommand(const std::string &name, command::Command *command);
 
-  void entityRegistration( void );
-  void entityDeregistration( void );
+  void entityRegistration();
+  void entityDeregistration();
 
- public:
-  Entity( const std::string& name );
-  virtual ~Entity( void );
-
-  static const std::string CLASS_NAME;
-  const std::string& getName( void ) const { return name; }
-  virtual const std::string& getClassName( void ) const { return CLASS_NAME; }
+  void signalRegistration(const SignalArray<int> &signals);
+  void signalDeregistration(const std::string &name);
 
- protected: /* --- SIGNALS --- */
-  typedef   std::map< std::string,SignalBase<int>* > SignalMap;
+  std::string name;
   SignalMap signalMap;
-  void signalRegistration( const SignalArray<int>& signals );
-  void signalDeregistration( const std::string& name );
- public:
-  SignalBase<int>& getSignal( const std::string & signalName );
-  const SignalBase<int>& getSignal( const std::string & signalName ) const;
-  std::ostream& displaySignalList( std::ostream& os ) const;
-  virtual std::ostream& writeGraph( std::ostream& os ) const;
-  virtual std::ostream& writeCompletionList( std::ostream& os ) const;
-
- public: /* --- DISPLAY --- */
-  virtual void display( std::ostream& os ) const; 
-
- public: /* --- PARAMS --- */
-  virtual void commandLine( const std::string& cmdLine,std::istringstream& cmdArgs,
-			    std::ostream& os );
-
-  virtual SignalBase<int>* test(void) { return 0; }
-  virtual void test2( SignalBase<int>* ptr ) { return ; }
-
-  virtual const std::string& getCommandList( void ) const;
+  CommandMap_t commandMap;
+  Logger logger_;
 };
 
-DYNAMICGRAPH_EXPORT std::ostream& operator<< (std::ostream& os, const dynamicgraph::Entity& ent );
-
-} // namespace dynamicgraph
-#endif /* #ifndef __ENTITY_HH__ */
-
-
-
+DYNAMIC_GRAPH_DLLAPI std::ostream &operator<<(std::ostream &os,
+                                              const dynamicgraph::Entity &ent);
+}  // end of namespace dynamicgraph
 
+#endif  //! DYNAMIC_GRAPH_ENTITY_H

include/dynamic-graph/exception-abstract.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __ABSTRACT_EXCEPTION_H
-#define __ABSTRACT_EXCEPTION_H
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-
-/* Classes standards. */
-#include <iostream>                /* Classe ostream.    */
-#include <string>                  /* Classe string.     */
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
+#define DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
 #include <dynamic-graph/dynamic-graph-api.h>
 
+#include <dynamic-graph/fwd.hh>
+#include <string>
 
 // Uncomment this macros to have lines parameter on the throw display
-// #define DYNAMIC-GRAPH_EXCEPTION_PASSING_PARAM 
-
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
+// #define DYNAMIC-GRAPH_EXCEPTION_PASSING_PARAM
 
-namespace dynamicgraph {
+#define DG_RETHROW \
+  (const ::dynamicgraph::ExceptionAbstract &err) { throw err; }
 
-/* \class ExceptionAbstract
- */
-class DYNAMICGRAPH_EXPORT ExceptionAbstract : public std::exception
-{
+#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
+#define DG_THROW                                                         \
+  throw ::dynamicgraph::ExceptionAbstract::Param(__LINE__, __FUNCTION__, \
+                                                 __FILE__) +
+#else
+#define DG_THROW throw
+#endif  // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
 
+namespace dynamicgraph {
+/// \ingroup error
+///
+/// \brief Abstract root class for all dynamic-graph exceptions.
+class DYNAMIC_GRAPH_DLLAPI ExceptionAbstract : public std::exception {
  public:
-
-  enum ExceptionEnum
-    {
-      ABSTRACT = 0
-      ,SIGNAL = 100
-      ,FACTORY = 200
-      ,TRACES = 300
-      ,TOOLS = 700
-    };
+  /// \ingroup error
+  ///
+  /// \brief Class owned by exceptions to store error locations.
+  class Param {
+   public:
+    static const int BUFFER_SIZE = 80;
+
+    Param(const int &_line, const char *_function, const char *_file);
+    Param()
+        : functionPTR(),
+          function(),
+          line(),
+          filePTR(),
+          file(),
+          pointersSet(false),
+          set(false) {}
+    Param &initCopy(const Param &p);
+
+    const char *functionPTR;
+    char function[BUFFER_SIZE];
+    int line;
+    const char *filePTR;
+    char file[BUFFER_SIZE];
+    bool pointersSet;
+    bool set;
+  };
+
+  /// \brief Categories error code.
+  ///
+  /// Each value matches categories used by a subclass of
+  /// ExceptionAbstract.
+  ///
+  /// This is the programmer responsibility to make sure there is
+  /// enough room between two categories error code.
+  enum ExceptionEnum {
+    ABSTRACT = 0,
+    SIGNAL = 100,
+    FACTORY = 200,
+    TRACES = 300,
+    TOOLS = 700
+  };
 
   static const std::string EXCEPTION_NAME;
-  virtual const std::string& getExceptionName( void ) const { return EXCEPTION_NAME; }
 
- protected:
-  /** Error code.
-   * \sa ErrorCodeEnum */
-  int code;
-
-  /**  Error message (can be empty). */
-  std::string message;
+  explicit ExceptionAbstract(const int &code, const std::string &msg = "");
+  virtual ~ExceptionAbstract() throw() {}
 
-private:
+  virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }
 
-  /**  forbid the empty constructor (private). */
-  ExceptionAbstract( void );
-public:
+  /// \brief Access to the error code.
+  int getCode() const;
 
-  ExceptionAbstract( const int& code, const std::string & msg = "" );
-  virtual ~ExceptionAbstract( void ) throw() {}
+  /// \brief Reference access to the error message (can be empty).
+  const std::string &getStringMessage() const;
 
-  /**  Access to the error code. */
-  int getCode (void);
+  /// \brief Access to the pointer on the array of \e char related
+  /// to the error string.
+  ///
+  /// Cannot be \e NULL.
+  const char *getMessage() const;
 
-  /** Reference access to the error message (can be empty). */
-  const std::string& getStringMessage (void) const;
-
-  /** Access to the pointer on the array of  \e char related to the error string.
-   * Cannot be  \e NULL.
-   */
-  const char *getMessage (void);
-
-  virtual const char* what() const throw()
-  {
+  virtual const char *what() const throw() {
     return getStringMessage().c_str();
   }
-  
-  /** Print the error structure. */
-  DYNAMICGRAPH_EXPORT friend std::ostream & operator << (std::ostream & os,
-				     const ExceptionAbstract & err);
 
-#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM 
- public:
-  class Param
-    {
-    public:
-      static const int BUFFER_SIZE = 80;
-
-      const char * functionPTR;
-      char function[ BUFFER_SIZE ];
-      int line;
-      const char * filePTR;
-      char file[ BUFFER_SIZE ];
-      bool pointersSet,set;
-    public:
-      Param( const int& _line, const char * _function, const char * _file );
-      Param( void ) : pointersSet(false),set(false) {}
-      Param& initCopy( const Param& p );
-	
-    };
+  /// \brief Print the error structure.
+  DYNAMIC_GRAPH_DLLAPI friend std::ostream &operator<<(
+      std::ostream &os, const ExceptionAbstract &err);
 
  protected:
-  mutable Param p;
-
-  template<class Exc>
-    friend const Exc& operator+ ( const ExceptionAbstract::Param& p, const Exc& e )
-    { e.p.initCopy(p);   return e;    }
-  template<class Exc>
-    friend Exc& operator+ ( const ExceptionAbstract::Param& p, Exc& e )
-    { e.p.initCopy(p);   return e;    }
-#endif //#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM 
-};
-
-} // namespace dynamicgraph
+  /// \brief Error code.
+  /// \sa ErrorCodeEnum
+  int code;
 
-#define DG_RETHROW ( const ExceptionAbstract& err ) { throw err; }
+  /// \brief Error message (can be empty).
+  std::string message;
 
+#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
+  /// \brief Optional mutable attribute to store exception location.
+  ///
+  /// Only present if DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
+  /// preprocessor symbol exists.
+  mutable Param p;
 
+  template <class Exc>
+  friend const Exc &operator+(const ExceptionAbstract::Param &p, const Exc &e) {
+    e.p.initCopy(p);
+    return e;
+  }
 
-#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
-#  define DG_THROW throw ExceptionAbstract::Param(__LINE__,__FUNCTION__,__FILE__) +
-#else //#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM 
-#  define DG_THROW throw
-#endif //#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM 
+  template <class Exc>
+  friend Exc &operator+(const ExceptionAbstract::Param &p, Exc &e) {
+    e.p.initCopy(p);
+    return e;
+  }
 
+#endif  // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
 
-#endif /* #ifndef __ABSTRACT_EXCEPTION_H */
+ private:
+  /// \brief Forbid the empty constructor (private).
+  ExceptionAbstract();
+};
+}  // end of namespace dynamicgraph
 
-/*
- * Local variables:
- * c-basic-offset: 2
- * End:
- */
+#endif  //! DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H

include/dynamic-graph/exception-factory.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
 
-#ifndef __EXCEPTION_FACTORY_H
-#define __EXCEPTION_FACTORY_H
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-
-#include <dynamic-graph/exception-abstract.h>
+#ifndef DYNAMIC_GRAPH_EXCEPTION_FACTORY_H
+#define DYNAMIC_GRAPH_EXCEPTION_FACTORY_H
 #include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/exception-abstract.h>
 
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
+#include <dynamic-graph/fwd.hh>
+#include <string>
 
 namespace dynamicgraph {
-
-/* \class sotExceptionFactory
- */
-class DYNAMICGRAPH_EXPORT ExceptionFactory
-:public ExceptionAbstract
-
-{
-public:
-
-  enum ErrorCodeEnum
-    {
-      GENERIC = ExceptionAbstract::FACTORY
-      ,UNREFERED_OBJECT
-      ,UNREFERED_SIGNAL
-      ,UNREFERED_FUNCTION
-      ,DYNAMIC_LOADING
-      ,SIGNAL_CONFLICT
-      ,FUNCTION_CONFLICT
-      ,OBJECT_CONFLICT
-      ,SYNTAX_ERROR    // j' aime bien FATAL_ERROR aussi faut que je la case qq part...
-      ,READ_FILE
-    };
+/// \ingroup error
+///
+/// \brief Generic error class.
+class DYNAMIC_GRAPH_DLLAPI ExceptionFactory : public ExceptionAbstract {
+ public:
+  enum ErrorCodeEnum {
+    GENERIC = ExceptionAbstract::FACTORY,
+    UNREFERED_OBJECT,
+    UNREFERED_SIGNAL,
+    UNREFERED_FUNCTION,
+    DYNAMIC_LOADING,
+    SIGNAL_CONFLICT,
+    FUNCTION_CONFLICT,
+    OBJECT_CONFLICT,
+    SYNTAX_ERROR,
+    READ_FILE
+  };
 
   static const std::string EXCEPTION_NAME;
-  virtual const std::string& getExceptionName( void )const{ return ExceptionFactory::EXCEPTION_NAME; }
-
-  ExceptionFactory ( const ExceptionFactory::ErrorCodeEnum& errcode,
-			const std::string & msg = "" );
-  ExceptionFactory ( const ExceptionFactory::ErrorCodeEnum& errcode,
-			const std::string & msg,const char* format, ... );
-  virtual ~ExceptionFactory( void ) throw() {}
-
-};
 
+  explicit ExceptionFactory(const ExceptionFactory::ErrorCodeEnum &errcode,
+                            const std::string &msg = "");
 
-} // namespace dynamicgraph
+  ExceptionFactory(const ExceptionFactory::ErrorCodeEnum &errcode,
+                   const std::string &msg, const char *format, ...);
 
+  virtual ~ExceptionFactory() throw() {}
 
-#endif /* #ifndef __EXCEPTION_FACTORY_H */
+  virtual const std::string &getExceptionName() const {
+    return ExceptionFactory::EXCEPTION_NAME;
+  }
+};
+}  // end of namespace dynamicgraph
 
-/*
- * Local variables:
- * c-basic-offset: 2
- * End:
- */
+#endif  //! DYNAMIC_GRAPH_EXCEPTION_FACTORY_H

include/dynamic-graph/exception-signal.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
 
-#ifndef __SIGNAL_EXCEPTION_H
-#define __SIGNAL_EXCEPTION_H
+#ifndef DYNAMIC_GRAPH_EXCEPTION_SIGNAL_H
+#define DYNAMIC_GRAPH_EXCEPTION_SIGNAL_H
 
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-
-#include <dynamic-graph/exception-abstract.h>
 #include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/exception-abstract.h>
 
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
+#include <dynamic-graph/fwd.hh>
 
 namespace dynamicgraph {
-
-/* \class sotExceptionSignal
- */
-class DYNAMICGRAPH_EXPORT ExceptionSignal
-:public ExceptionAbstract
-
-{
+/// \ingroup error
+///
+/// \brief Exceptions raised when an error related to signals
+/// happen.
+class DYNAMIC_GRAPH_DLLAPI ExceptionSignal : public ExceptionAbstract {
  public:
-  enum ErrorCodeEnum
-    {
-      GENERIC = ExceptionAbstract::SIGNAL
-
-      ,READWRITE_LOCK
-      ,COPY_NOT_INITIALIZED
-      ,NOT_INITIALIZED
-      ,PLUG_IMPOSSIBLE
-      ,SET_IMPOSSIBLE
-      ,BAD_CAST
-    };
+  enum ErrorCodeEnum {
+    GENERIC = ExceptionAbstract::SIGNAL,
+    READWRITE_LOCK,
+    COPY_NOT_INITIALIZED,
+    NOT_INITIALIZED,
+    PLUG_IMPOSSIBLE,
+    SET_IMPOSSIBLE,
+    BAD_CAST
+  };
 
   static const std::string EXCEPTION_NAME;
-  virtual const std::string& getExceptionName( void ) const { return EXCEPTION_NAME; }
-
-public:
-
-  ExceptionSignal ( const ExceptionSignal::ErrorCodeEnum& errcode,
-		       const std::string & msg = "" );
-  ExceptionSignal( const ExceptionSignal::ErrorCodeEnum& errcode,
-			const std::string & msg,const char* format, ... );
-  virtual ~ExceptionSignal( void ) throw() {}
 
+  explicit ExceptionSignal(const ExceptionSignal::ErrorCodeEnum &errcode,
+                           const std::string &msg = "");
+  ExceptionSignal(const ExceptionSignal::ErrorCodeEnum &errcode,
+                  const std::string &msg, const char *format, ...);
+  virtual ~ExceptionSignal() throw() {}
 
+  virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }
 };
 
-} // namespace dynamicgraph
-
-
-
-#endif /* #ifndef __SIGNAL_EXCEPTION_H */
+}  // end of namespace dynamicgraph
 
-/*
- * Local variables:
- * c-basic-offset: 2
- * End:
- */
+#endif  //! DYNAMIC_GRAPH_EXCEPTION_SIGNAL_H

include/dynamic-graph/exception-traces.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
 
-#ifndef __TRACES_EXCEPTION_H
-#define __TRACES_EXCEPTION_H
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-
-#include <dynamic-graph/exception-abstract.h>
+#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>
 
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
+#include <dynamic-graph/fwd.hh>
+#include <string>
 
 namespace dynamicgraph {
-
-/* \class ExceptionTraces
- */
-class DYNAMICGRAPH_EXPORT ExceptionTraces
-:public ExceptionAbstract
-
-{
+/// \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
-    };
+  enum ErrorCodeEnum { GENERIC = ExceptionAbstract::TRACES, NOT_OPEN };
 
   static const std::string EXCEPTION_NAME;
-  virtual const std::string& getExceptionName( void ) const { return EXCEPTION_NAME; }
-
-public:
-
-  ExceptionTraces ( const ExceptionTraces::ErrorCodeEnum& errcode,
-		       const std::string & msg = "" );
-  ExceptionTraces( const ExceptionTraces::ErrorCodeEnum& errcode,
-			const std::string & msg,const char* format, ... );
-  virtual ~ExceptionTraces( void ) throw () {}
 
+  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.
 
-
-
-} //namespace dynamicgraph
-
-
-
-
-#endif /* #ifndef __TRACES_EXCEPTION_H */
-
-/*
- * Local variables:
- * c-basic-offset: 2
- * End:
- */
+#endif  //! DYNAMIC_GRAPH_EXCEPTION_TRACES_H

include/dynamic-graph/factory.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __FACTORY_HH__
-#define __FACTORY_HH__
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/* --- STD --- */
-#include <map>
-#include <string>
+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
 
-/* --- DYNAMIC-GRAPH --- */
-#include <dynamic-graph/exception-factory.h>
+#ifndef DYNAMIC_GRAPH_FACTORY_HH
+#define DYNAMIC_GRAPH_FACTORY_HH
 #include <dynamic-graph/dynamic-graph-api.h>
+#include <dynamic-graph/exception-factory.h>
 
-namespace dynamicgraph {
+#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
 
-class Entity;
-
-/* --------------------------------------------------------------------- */
-/* --- FACTORY ---------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/*! \class FactoryStorage
- *  \ingroup dgraph
- *  \brief The Factory class is responsible for creating Entity objects.
- *
- *  Entities can register themselves through the helper class EntityRegisterer.
- *  This object also provides access to command-line functions.
- *
- *
- */
-class DYNAMICGRAPH_EXPORT FactoryStorage
-{
+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;
 
-  typedef Entity* (*EntityConstructor_ptr)( const std::string& );
-
- protected:
-  typedef std::map< std::string,EntityConstructor_ptr > EntityMap;
-
+ 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;
 
- public:
-
-  ~FactoryStorage( void );
-
-  void registerEntity( const std::string& entname,EntityConstructor_ptr ent );
-  void deregisterEntity( const std::string& entname );
-  Entity* newEntity( const std::string& name,const std::string& objname );
-  bool existEntity( const std::string& name, EntityMap::iterator& entPtr );
-  bool existEntity( const std::string& name );
-
-  void  commandLine( const std::string& cmdLine,std::istringstream& cmdArgs,
-		     std::ostream& os );
-
-
+  /// \pointer to the unique object of the class
+  static FactoryStorage *instance_;
 };
 
-DYNAMICGRAPH_EXPORT extern FactoryStorage g_factory;
-
-/* --- REGISTERER ----------------------------------------------------------- */
-/* --- REGISTERER ----------------------------------------------------------- */
-/* --- REGISTERER ----------------------------------------------------------- */
+/// \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);
 
-/* -------------------------------------------------------------------------- */
-/* --- ENTITY REGISTERER ---------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
+  /// \brief Unregister entity to the global factory.
+  ~EntityRegisterer();
 
-/*! A helper class to register an entity.
- *
- */
-class DYNAMICGRAPH_EXPORT EntityRegisterer
-{
  private:
-  EntityRegisterer( void );
-  std::string entityName;
-
- public:
-  EntityRegisterer( const std::string& entityClassName,
-		       FactoryStorage::EntityConstructor_ptr maker);
-
-  ~EntityRegisterer( void );
+  /// \brief Name of the entity registered when the instance has
+  /// been initialized.
+  const std::string entityName;
 };
+}  // end of namespace dynamicgraph
 
-/*! This macro should be used to automatically register an entity
- * of classType to the g_factory. It is then possible to create it
- * with the g_factory.
- */
-#define DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(classType,className) \
-  const std::string classType::CLASS_NAME = className; \
-  extern "C" {                                            \
-    Entity *EntityMaker##_##classType( const std::string& objname )    \
-    {                                                     \
-      return new classType( objname );                 \
-    }                                                     \
-  EntityRegisterer reg##_##classType( className,    \
-					    &EntityMaker##_##classType );   \
-  }                                                       \
-
-}  // namespace dynamicgraph
-
-#endif /* #ifndef __FACTORY_HH__ */
-
-
-
+#endif  //! DYNAMIC_GRAPH_FACTORY_HH
 
+//  LocalWords:  unregister

include/dynamic-graph/functions.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __SHELL_FUNCTIONS_HH__
-#define __SHELL_FUNCTIONS_HH__
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/* DYNAMIC-GRAPH */
-#include <dynamic-graph/exception-factory.h>
-#include <dynamic-graph/interpreter.h>
-#include <dynamic-graph/dynamic-graph-api.h>
-
-/* --- STD --- */
-#include <string>
-#include <map>
-#include <sstream>
-
-/* --- BOOST --- */
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-#define STATIC_SHELL_FUNCTION( name ) \
-  static void name( const std::string cmd,std::istringstream& args, \
-                       std::ostream& os )
-
-/*! @ingroup dgraph
-  \brief This plugin implements a bunch of useful shell commands.
-
-  These include debug commands such as timing and exception catching,
-  and user interaction commands such as display and beep commands.
-  For more information, load the plugin and type help on a sot shell.
- */
-class DYNAMICGRAPH_EXPORT ShellFunctions
-{
- public:
-
-  STATIC_SHELL_FUNCTION( cmdLoadPlugins );
-  STATIC_SHELL_FUNCTION( cmdTry );
-  STATIC_SHELL_FUNCTION( cmdDisplayPlugins );
-  STATIC_SHELL_FUNCTION( cmdDisplayFactory );
-  STATIC_SHELL_FUNCTION( cmdCommentary );
-  STATIC_SHELL_FUNCTION( cmdUnplug );
-  STATIC_SHELL_FUNCTION( cmdClearPlugin );
-  STATIC_SHELL_FUNCTION( cmdSignalTime );
-  STATIC_SHELL_FUNCTION( cmdSynchroSignal );
-  STATIC_SHELL_FUNCTION( cmdEcho );
-  STATIC_SHELL_FUNCTION( cmdCopy );
-  STATIC_SHELL_FUNCTION( cmdFreeze );
-  STATIC_SHELL_FUNCTION( cmdSqueeze );
-  STATIC_SHELL_FUNCTION( cmdEnableTrace );
-  STATIC_SHELL_FUNCTION( cmdSetPrompt );
-  STATIC_SHELL_FUNCTION( cmdSleep );
-  STATIC_SHELL_FUNCTION( cmdBeep );
-  STATIC_SHELL_FUNCTION( cmdFlagSet );
-  STATIC_SHELL_FUNCTION( cmdCompletionList );
-};
-
-
-#endif //#ifndef __DYNAMIC-GRAPH_SHELL_FUNCTIONS_HH__

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/interpreter-helper.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __INTERPRETER_HELPER_HH__
-#define __INTERPRETER_HELPER_HH__
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/* DYNAMIC-GRAPH */
-#include <dynamic-graph/signal-base.h>
-#include <dynamic-graph/exception-factory.h>
-#include <dynamic-graph/pool.h>
-#include <dynamic-graph/dynamic-graph-api.h>
-#include <dynamic-graph/plugin-loader.h>
-
-/* --- STD --- */
-#include <string>
-#include <map>
-#include <sstream>
-
-/* --- BOOST --- */
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-
-namespace dynamicgraph {
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/*! @ingroup dgraph
-  \brief This class implements the first level interpretor
-  to control basic functionnalities of the plugins.
-
-  It provides a shell allowing to :
-  \li load plugin libraries,
-  \li create instances of plugin,
-  \li destroy the plugins,
-  \li unload the libraries,
-  \li set a signal,
-  \li get a signal,
-  \li compute a signal,
-*/
-class DYNAMICGRAPH_EXPORT InterpreterHelper
-{
-
- public:
-  /*! \brief Default constructor
-    \par[in] dlPtr: a plugin loader to perform the actions provided by this shell.
-   */
-  InterpreterHelper( );
-
-
- protected:
-
-  /*! \brief The plugin loader */
-  PluginLoader dlPtr;
-
- public:
-
-  /*! \name Implements the commands.
-    @{
-   */
-  /*! \brief Instanciante an object
-    Extracts the name and the class of the object, verifies it is unique,
-    and creates the instance if this is the case.
-   */
-  void cmdNew(const std::string& className,
-	      const std::string& objName,
-	      std::ostream& os);
-
-  /*! \brief Destroy the object.
-    Destroy the object objName.
-   */
-  void cmdDestroy( const std::string& objName, 
-		   std::ostream& os );
-
-  /*! \brief Connect two signals.
-    Connect the input signal obj1.signame1 to the output signal
-    obj2.signame2.
-    \param[in] obj1.signame1: the input signal.
-    \param[in] obj2.signame2: the output signal.
-  */
-  void cmdPlug( const std::string& obj1, const std::string & signame1,
-		const std::string& obj2, const std::string & signame2,
-		std::ostream& os  );
-
-  /*! \brief Load a dynamic library which includes a plugin.
-    Extracts the name first and the directory in second from cmdArg
-    to load the dynamic library.
-   */
-  void cmdLoadPlugin( const std::string& directory, 
-		      const std::string& pluginName, 
-		      std::ostream& os );
-
-  /*! \brief Unload a dynamic library which includes a plugin.
-    Extracts the name to unload the dynamic library.
-  */
-  void cmdUnloadPlugin( const std::string& pluginName, 
-			std::ostream& os );
-
-  /*! \brief Set a signal <obj.signal> to a value <value>
-    with cmdArg = "<obj.signal> <value>"
-   */
-  void cmdSetSignal( const std::string& objname, 
-		     const std::string& signame,
-		     const std::string& cmdArg,
-		     std::ostream& os);
-
-  /*! \brief Display the value of the signal <obj.signal>
-    with cmdArg = "<obj.signal>"
-   */
-  void cmdGetSignal( const std::string& objname, 
-		     const std::string& signame, 
-		     std::ostream& os);
-
-  /*! \brief Compute the value of the signal <obj.signal> at time <time>
-    with cmdArg = "<obj.signal> <time>"
-   */
-  void cmdComputeSignal( const std::string& objname,
-			 const std::string& signame, 
-			 const int &time,
-			 std::ostream& os );
-
-};
-
-
-} // namespace dynamicgraph
-
-
-
-#endif /* #ifndef  */
-
-
-
-

include/dynamic-graph/interpreter.h

-/*
- * Copyright 2010,
- * François Bleibel,
- * Olivier Stasse,
- *
- * CNRS/AIST
- *
- * This file is part of dynamic-graph.
- * dynamic-graph is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * dynamic-graph is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with dynamic-graph.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __INTERPRETER_HH__
-#define __INTERPRETER_HH__
-
-/* --------------------------------------------------------------------- */
-/* --- INCLUDE --------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-
-/* DYNAMIC-GRAPH */
-#include <dynamic-graph/signal-base.h>
-#include <dynamic-graph/exception-factory.h>
-#include <dynamic-graph/pool.h>
-#include <dynamic-graph/dynamic-graph-api.h>
-
-/* --- STD --- */
-#include <string>
-#include <map>
-#include <sstream>
-
-/* --- BOOST --- */
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-
-namespace dynamicgraph {
-/* --------------------------------------------------------------------- */
-/* --- CLASS ----------------------------------------------------------- */
-/* --------------------------------------------------------------------- */
-class PluginLoader;
-
-/*! @ingroup dgraph
-  \brief This class implements the first level interpretor
-  to control basic functionnalities of the plugins.
-
-  It provides a shell allowing to :
-  \li load plugin libraries,
-  \li create instances of plugin,
-  \li destroy the plugins,
-  \li unload the libraries,
-  \li set a signal,
-  \li get a signal,
-  \li run scripts,
-  \li compute a signal,
-  \li act as a proxy for the commands of the plugins.
-*/
-class DYNAMICGRAPH_EXPORT Interpreter
-{
-
- public:
-  /*! \brief Type of a basic function for the shell.
-    Such function returns a void and takes 3 arguments:
-    \li the functionnality (i.e. the method) it provides to the shell,
-    \li a stream of input string to pass when called,
-    \li an output stream for display.
-  */
-  typedef boost::function3<void,const std::string&,std::istringstream&,std::ostream&> ShellBasicFunction;
- protected:
-  /*! \brief This type defines a sorted set of basic functions with a unique key. */
-  typedef std::map< std::string,ShellBasicFunction > FunctionMap;
-  /*! Instance of this type. */
-  FunctionMap functionMap;
-
- public:
-  /*! \brief Default constructor
-    \par[in] dlPtr: a plugin loader to perform the actions provided by this shell.
-   */
-  Interpreter( PluginLoader* dlPtr=NULL );
-
-  typedef PluginLoader * sotPluginLoaderPTR;
-  /*! \brief The plugin loader */
-  sotPluginLoaderPTR dlPtr;
-
- protected:
-  bool initDone; // Debug
- public:
-  std::string prompt;
-  static const std::string PROMPT_DEFAULT;
-
- public:
-  /*! \brief Register a function at the upper level of the shell.
-    \par[in] funname: The function's name,
-    \par[in] fun: The pointer to the function.
-  */
-  void registerFunction( const std::string& funname, const ShellBasicFunction& fun );
-  bool deregisterFunction( const std::string& funname );
-
-
-  /*! \brief Set the reference of the plugin loader. */
-  void referencePluginLoader( PluginLoader* dl__ )
-  { dlPtr = dl__; }
-
- public:
-
-  /*! \name Implements the commands.
-    @{
-   */
-  /*! \brief Instanciante an object
-    Extracts the name and the class of the object, verifies it is unique,
-    and creates the instance if this is the case.
-   */
-  void cmdNew( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-  /*! \brief Destroy the object.
-    Extracts the name for cmdArg and destroy the object.
-   */
-  void cmdDestroy( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-  /*! \brief Connect two signals.
-    Connect an input signal to an output one.
-  */
-  void cmdPlug( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-  /*! \brief Load a dynamic library which includes a plugin.
-    Extracts the name first and the directory in second from cmdArg
-    to load the dynamic library.
-   */
-  void cmdLoadPlugin( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Unload a dynamic library which includes a plugin.
-    Extracts the name to unload the dynamic library.
-  */
-  void cmdUnloadPlugin( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Ask to each register function to display its help. */
-  void cmdHelp( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Run a script */
-  void cmdRun( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Set a signal <obj.signal> to a value <value>
-    with cmdArg = "<obj.signal> <value>"
-   */
-  void cmdSetSignal( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Display the value of the signal <obj.signal>
-    with cmdArg = "<obj.signal>"
-   */
-  void cmdGetSignal( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Compute the value of the signal <obj.signal> at time <time>
-    with cmdArg = "<obj.signal> <time>"
-   */
-  void cmdComputeSignal( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Entry point to treat a command. */
-  void cmd( const std::string& cmdLine, std::istringstream& cmdArg, std::ostream& os );
-
-  /*! \brief Extract the object name and the function name from a command. */
-  static bool objectNameParser( std::istringstream& cmdparse,
-				std::string& objName,std::string& funName );
-
-  /*! @} */
-
- public:
-  /*! \brief Method to start the shell.
-    \par[in] sin: The input stream from which the command will be extracted.
-    \par[out] sout: The output stream to which the result will be displayed.
-    \par[in] prompt: The prompt to be displayed.
-
-   */
-  void shell( std::istream& sin, std::ostream& sout, const std::string& prompt="" );
-  void writeCompletionList(std::ostream& os);
-
-
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-/*! \brief Class for automatic registration of shell functions.
- * Use the macro DYNAMIC-GRAPH_SHELL_FUNCTION_REGISTERER(name, fun) in a .cpp file
- * to register functions on plugin load.
- */
-class DYNAMICGRAPH_EXPORT ShellFunctionRegisterer
-
-{
-public:
-	ShellFunctionRegisterer( const std::string& funName,
-			      const Interpreter::ShellBasicFunction& f);
-};
-
-#define SHELL_FUNCTION_REGISTERER(name,fun)           \
-  extern "C" {                                            \
-	ShellFunctionRegisterer reg( name,boost::bind(fun,_1,_2,_3) );\
-  }
-
-DYNAMICGRAPH_EXPORT extern Interpreter g_shell;
-
-} // namespace dynamicgraph
-
-
-
-#endif /* #ifndef  */
-
-
-
-

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