test_depend.cpp

Go to the documentation of this file.

/*
 * Copyright 2010,
 * François Bleibel,
 * Olivier Stasse,
 *
 * CNRS/AIST
 *
 */
 
/* -------------------------------------------------------------------------- */
/* --- INCLUDES ------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
#include <dynamic-graph/all-signals.h>
#include <dynamic-graph/linear-algebra.h>
 
#include <iostream>
#include <sot/core/debug.hh>
 
using namespace std;
using namespace dynamicgraph;
 
template <class Res = double>
class DummyClass {
 public:
  std::string proname;
  list<SignalTimeDependent<double, sigtime_t> *> inputsig;
  list<SignalTimeDependent<dynamicgraph::Vector, sigtime_t> *> inputsigV;
 
 public:
  DummyClass(const std::string &n) : proname(n), res(), appel(0), timedata(0) {}
 
  Res &fun(Res &res, int t) {
    appel++;
    timedata = t;
 
    cout << "Inside " << proname << " -> " << this << endl;
    for (list<SignalTimeDependent<double, sigtime_t> *>::iterator it =
             inputsig.begin();
         it != inputsig.end(); ++it) {
      cout << *(*it) << endl;
      (*it)->access(timedata);
    }
    for (list<SignalTimeDependent<dynamicgraph::Vector, sigtime_t> *>::iterator
             it = inputsigV.begin();
         it != inputsigV.end(); ++it) {
      cout << *(*it) << endl;
      (*it)->access(timedata);
    }
 
    return res = (*this)();
  }
 
  void add(SignalTimeDependent<double, sigtime_t> &sig) {
    inputsig.push_back(&sig);
  }
  void add(SignalTimeDependent<dynamicgraph::Vector, sigtime_t> &sig) {
    inputsigV.push_back(&sig);
  }
 
  Res operator()(void);
 
  Res res;
  int appel;
  int timedata;
};
 
template <class Res>
Res DummyClass<Res>::operator()(void) {
  return this->res;
}
 
template <>
double DummyClass<double>::operator()(void) {
  res = appel * timedata;
  return res;
}
template <>
dynamicgraph::Vector DummyClass<dynamicgraph::Vector>::operator()(void) {
  res.resize(3);
  res.fill(appel * timedata);
  return res;
}
 
int main(void) {
  DummyClass<double> pro1("pro1"), pro3("pro3"), pro5("pro5");
  DummyClass<dynamicgraph::Vector> pro2("pro2"), pro4("pro4"), pro6("pro6");
 
  SignalTimeDependent<double, sigtime_t> sig5("Sig5");
  SignalTimeDependent<dynamicgraph::Vector, sigtime_t> sig6("Sig6");
 
  SignalTimeDependent<dynamicgraph::Vector, sigtime_t> sig4(sig5, "Sig4");
  SignalTimeDependent<dynamicgraph::Vector, sigtime_t> sig2(
      sig4 << sig4 << sig4 << sig6, "Sig2");
  SignalTimeDependent<double, sigtime_t> sig3(sig2 << sig5 << sig6, "Sig3");
  SignalTimeDependent<double, sigtime_t> sig1(
      boost::bind(&DummyClass<double>::fun, &pro1, _1, _2), sig2 << sig3,
      "Sig1");
 
  sig2.setFunction(
      boost::bind(&DummyClass<dynamicgraph::Vector>::fun, &pro2, _1, _2));
  sig3.setFunction(boost::bind(&DummyClass<double>::fun, &pro3, _1, _2));
  sig4.setFunction(
      boost::bind(&DummyClass<dynamicgraph::Vector>::fun, &pro4, _1, _2));
  sig5.setFunction(boost::bind(&DummyClass<double>::fun, &pro5, _1, _2));
  sig6.setFunction(
      boost::bind(&DummyClass<dynamicgraph::Vector>::fun, &pro6, _1, _2));
 
  pro1.add(sig2);
  pro1.add(sig3);
  pro2.add(sig4);
  pro2.add(sig4);
  pro2.add(sig4);
  pro3.add(sig2);
  pro4.add(sig5);
  pro2.add(sig6);
  pro3.add(sig5);
  pro3.add(sig6);
 
  sig5.setDependencyType(TimeDependency<sigtime_t>::ALWAYS_READY);
  sig6.setDependencyType(TimeDependency<sigtime_t>::BOOL_DEPENDENT);
 
  sig6.setReady();
 
  sig1.displayDependencies(cout) << endl;
 
  cout << "Needs update?" << endl << sig1.needUpdate(2) << endl;
  dgDEBUG(1) << "Access sig1(2) " << endl;
  sig1.access(2);
  sig1.displayDependencies(cout) << endl;
  dgDEBUG(1) << "Access sig2(4) " << endl;
  sig2.access(4);
  sig1.displayDependencies(cout) << endl;
  dgDEBUG(1) << "Access sig1(4) " << endl;
  sig1.access(4);
  sig1.displayDependencies(cout) << endl;
 
  sig1.needUpdate(6);
  sig1.needUpdate(6);
 
  return 0;
}