dynamicGraph.pc.cmake

-prefix=${CMAKE_INSTALL_PREFIX}
-exec_prefix=${install_pkg_prefix}
-libdir=${install_pkg_exec_prefix}/lib
-includedir=${install_pkg_prefix}/include
-datarootdir=${install_pkg_prefix}/share
-docdir=${install_pkg_datarootdir}/doc/${PROJECT_NAME}
-
-Name: ${PROJECT_NAME}
-Description: 
-Version: ${PROJECT_VERSION}
-Requires: ${PACKAGE_REQUIREMENTS}
-Libs: ${LIBDIR_KW}${install_pkg_libdir} ${${PROJECT_NAME}_LDFLAGS}
-Cflags: -I${install_pkg_include_dir} ${${PROJECT_NAME}_CXXFLAGS}

include/CMakeLists.txt

-# 
-#  Copyright 
-# 
-
-SET(${PROJECT_NAME}_HEADERS
-dynamicGraph-API.h
-)
-
-# Recreate correct path for the headers
-#--------------------------------------
-
-SET(fullpath_${PROJECT_NAME}_HEADERS)
-FOREACH(lHeader ${${PROJECT_NAME}_HEADERS})
-  SET(fullpath_${PROJECT_NAME}_HEADERS 
-    ${fullpath_${PROJECT_NAME}_HEADERS}
-    ./${lHeader}
-  )
-
-ENDFOREACH(lHeader)
-
-#----------------------------------------------------
-# Install procedure for the header files
-#----------------------------------------------------
-INSTALL(FILES ${fullpath_${PROJECT_NAME}_HEADERS}
-	DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${PROJECT_NAME}
-        PERMISSIONS OWNER_READ GROUP_READ WORLD_READ OWNER_WRITE
-)

include/dynamic-graph/all-commands.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Olivier Stasse, JRL, CNRS/AIST
+//                 Thomas Moulard, Nicolas Mansard  LAAS-CNRS
+//
+
+#ifndef DYNAMIC_GRAPH_ALL_COMMANDS_H
+#define DYNAMIC_GRAPH_ALL_COMMANDS_H
+
+// Utility header files including all commands headers
+
+#include <dynamic-graph/command-bind.h>
+#include <dynamic-graph/command-direct-getter.h>
+#include <dynamic-graph/command-direct-setter.h>
+#include <dynamic-graph/command-getter.h>
+#include <dynamic-graph/command-setter.h>
+#include <dynamic-graph/command.h>
+
+#endif  //! DYNAMIC_GRAPH_ALL_COMMANDS_H

include/dynamic-graph/all-signals.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_ALL_SIGNALS_H
+#define DYNAMIC_GRAPH_ALL_SIGNALS_H
+
+// Utility header files including all signal headers
+
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+#include <dynamic-graph/signal.h>
+
+#endif  //! DYNAMIC_GRAPH_ALL_SIGNALS_H

include/dynamic-graph/command-direct-getter.h

+//
+// Copyright 2010 CNRS
+//
+// Author: Nicolas Mansard
+//
+
+#ifndef __dg_command_direct_getter_h__
+#define __dg_command_direct_getter_h__
+
+/* Define a getter command directly on the attribute (no need to pass by
+ * an explicit function). A typical use is given here:
+ *     addCommand("getSize",
+ *                makeDirectGetter(*this,&_dimension,
+ *                                 docDirectGetter("dimension","int")));
+ *
+ */
+
+#include <boost/assign/list_of.hpp>
+
+#include "dynamic-graph/command.h"
+
+/* --- GETTER --------------------------------------------------------- */
+namespace dynamicgraph {
+namespace command {
+
+template <class E, typename T>
+class DirectGetter : public Command {
+ public:
+  /// Pointer to method that sets parameter of type T
+  typedef T (E::*GetterMethod)() const;
+
+  /// Constructor
+  DirectGetter(E &entity, T *ptr, const std::string &docString)
+      : Command(entity, std::vector<Value::Type>(), docString), T_ptr(ptr) {}
+
+ protected:
+  virtual Value doExecute() { return Value(*T_ptr); }
+
+ private:
+  T *T_ptr;
+};
+
+template <class E, typename T>
+DirectGetter<E, T> *makeDirectGetter(E &entity, T *ptr,
+                                     const std::string &docString) {
+  return new DirectGetter<E, T>(entity, ptr, docString);
+}
+
+inline std::string docDirectGetter(const std::string &name,
+                                   const std::string &type) {
+  return std::string("\nGet the ") + name + ".\n\nNo input.\nReturn an " +
+         type + ".\n\n";
+}
+
+}  // namespace command
+}  // namespace dynamicgraph
+
+#endif  // __dg_command_direct_getter_h__

include/dynamic-graph/command-direct-setter.h

+//
+// Copyright 2010 CNRS
+//
+// Author: Nicolas Mansard
+//
+
+#ifndef __dg_command_direct_setter_h__
+#define __dg_command_direct_setter_h__
+
+/* Define a setter command directly on the attribute (no need to pass by
+ * an explicit function). A typical use is given here:
+ *     addCommand("setSize",
+ *                makeDirectSetter(*this,&_dimension,
+ *                                 docDirectSetter("dimension","int")));
+ *
+ */
+
+#include <boost/assign/list_of.hpp>
+
+#include "dynamic-graph/command.h"
+
+/* --- SETTER --------------------------------------------------------- */
+namespace dynamicgraph {
+namespace command {
+
+template <class E, typename T>
+class DirectSetter : public Command {
+ public:
+  DirectSetter(E &entity, T *ptr, const std::string &docString)
+      : Command(entity, boost::assign::list_of(ValueHelper<T>::TypeID),
+                docString),
+        T_ptr(ptr) {}
+
+ protected:
+  virtual Value doExecute() {
+    const std::vector<Value> &values = getParameterValues();
+    T val = values[0].value();
+    (*T_ptr) = val;
+    return Value();  // void
+  }
+
+ private:
+  T *T_ptr;
+};
+
+template <class E, typename T>
+DirectSetter<E, T> *makeDirectSetter(E &entity, T *ptr,
+                                     const std::string &docString) {
+  return new DirectSetter<E, T>(entity, ptr, docString);
+}
+
+inline std::string docDirectSetter(const std::string &name,
+                                   const std::string &type) {
+  return std::string("\nSet the ") + name + ".\n\nInput:\n - a " + type +
+         ".\nVoid return.\n\n";
+}
+
+}  // namespace command
+}  // namespace dynamicgraph
+
+#endif  // __dg_command_direct_setter_h__

include/dynamic-graph/command-getter.h

+//
+// Copyright 2010 CNRS
+//
+// Author: Florent Lamiraux
+//
+
+#ifndef DYNAMIC_GRAPH_COMMAND_GETTER_H
+#define DYNAMIC_GRAPH_COMMAND_GETTER_H
+
+#include "dynamic-graph/command.h"
+
+namespace dynamicgraph {
+namespace command {
+
+///
+/// Command that calls a parameter getter 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 getter function for this member:
+/// \code
+/// class E : public Entity
+/// {
+/// public:
+///   E (const std::string& inName) : Entity(inName) {}
+///   T getParameter() const {return parameter_;}
+/// private:
+///   T parameter_;
+/// };
+/// \endcode
+/// Then the command defined by:
+/// \code
+/// E entity("MyEntity");
+/// Getter<E,T> command(entity, &E::getParameter)
+/// \endcode
+/// returns the value of <c>entity.parameter_</c> upon invocation.
+///
+/// \note
+/// \li T should be a type supported by class Value,
+/// \li prototype of E::getParameter should be exactly as specified in this
+/// example.
+template <class E, typename T>
+class Getter : public Command {
+ public:
+  /// Pointer to method that sets parameter of type T
+  typedef T (E::*GetterMethod)() const;
+  /// Constructor
+  Getter(E &entity, GetterMethod getterMethod, const std::string &docString);
+
+ protected:
+  virtual Value doExecute();
+
+ private:
+  GetterMethod getterMethod_;
+};
+}  // namespace command
+}  // namespace dynamicgraph
+
+#include "dynamic-graph/command-getter.t.cpp"
+#endif  // DYNAMIC_GRAPH_COMMAND_GETTER_H

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.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/dynamic-graph-api.h

+// -*- mode: c++ -*-
+// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
+// JRL, CNRS/AIST.
+//
+
+#ifndef DYNAMIC_GRAPH_API_H
+#define DYNAMIC_GRAPH_API_H
+#include <dynamic-graph/config.hh>
+#endif  //! DYNAMIC_GRAPH_API_H