test_dep.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>
using namespace std;
using namespace dynamicgraph;
 
template <class Res = double>
class DummyClass {
 public:
  DummyClass(void) : res(), appel(0), timedata(0) {}
 
  Res &fun(Res &res, int t) {
    appel++;
    timedata = t;
 
    cout << "Inside " << 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)();
  }
 
  list<SignalTimeDependent<double, sigtime_t> *> inputsig;
  list<SignalTimeDependent<dynamicgraph::Vector, sigtime_t> *> inputsigV;
 
  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;
}
 
#include <vector>
int main(void) {
  DummyClass<double> pro1, pro3, pro5;
  DummyClass<dynamicgraph::Vector> pro2, pro4, 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));
 
  //    sig1.addDependency(sig2);
  //     sig1.addDependency(sig3);
  //      sig2.addDependency(sig4);
  //      sig2.addDependency(sig4);
  //     sig2.addDependency(sig4);
  //      sig3.addDependency(sig2);
  //      sig4.addDependency(sig5);
  //      sig2.addDependency(sig6);
  //      sig3.addDependency(sig5);
  //      sig3.addDependency(sig6);
 
  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;
  sig1.access(2);
  sig1.displayDependencies(cout) << endl;
  sig2.access(4);
  sig1.displayDependencies(cout) << endl;
  sig1.access(4);
  sig1.displayDependencies(cout) << endl;
  sig1.needUpdate(6);
  sig1.needUpdate(6);
 
  return 0;
}