time-dependency.t.cpp

// -*- mode: c++ -*-
// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
// JRL, CNRS/AIST.
//

#ifndef DYNAMIC_GRAPH_TIME_DEPENDENCY_T_CPP
#define DYNAMIC_GRAPH_TIME_DEPENDENCY_T_CPP
#include <dynamic-graph/time-dependency.h>

#undef VP_TEMPLATE_DEBUG_MODE
#define VP_TEMPLATE_DEBUG_MODE 0
#include <dynamic-graph/debug.h>

#define __TIME_DEPENDENCY_INIT(sig, dep)                                       \
  leader(*sig), dependencies(), updateFromAllChildren(ALL_READY_DEFAULT),      \
      dependencyType(dep), periodTime(PERIOD_TIME_DEFAULT)

namespace dynamicgraph {
template <class Time>
TimeDependency<Time>::TimeDependency(SignalBase<Time> *sig,
                                     const DependencyType dep)
    : __TIME_DEPENDENCY_INIT(sig, dep) {}

template <class Time>
TimeDependency<Time>::TimeDependency(SignalBase<Time> *sig,
                                     const SignalArray_const<Time> &ar,
                                     const DependencyType dep)
    : __TIME_DEPENDENCY_INIT(sig, dep) {
  addDependencies(ar);

  return;
}

/* ------------------------------------------------------------------------ */
template <class Time>
void TimeDependency<Time>::addDependencies(const SignalArray_const<Time> &ar) {
  for (unsigned int i = 0; i < ar.getSize(); ++i) {
    addDependency(ar[i]);
  }
}

template <class Time>
void TimeDependency<Time>::addDependency(const SignalBase<Time> &sig) {
  dependencies.push_front(&sig);
}

template <class Time>
void TimeDependency<Time>::removeDependency(const SignalBase<Time> &sig) {
  dependencies.remove(&sig);
}

template <class Time> void TimeDependency<Time>::clearDependency() {
  dependencies.clear();
}

template <class Time>
bool TimeDependency<Time>::needUpdate(const Time &t1) const {
  dgTDEBUG(15) << "# In {" << leader.getName() << " : (" << leader.getReady()
               << ") " << t1 << " >? " << leader.getTime() << std::endl;

  if (leader.getReady()) {
    dgTDEBUGOUT(15);
    return true;
  }
  if (lastAskForUpdate) {
    dgTDEBUGOUT(15);
    return true;
  }

  switch (dependencyType) {
  case ALWAYS_READY: {
    dgTDEBUGOUT(15);
    return true;
  }
  case BOOL_DEPENDENT:
    break;
  case TIME_DEPENDENT: {
    if (t1 < leader.getTime() + periodTime) {
      dgTDEBUGOUT(15);
      return false;
    }
    break;
  }
  };

  bool res = updateFromAllChildren;
  const typename Dependencies::const_iterator itend = dependencies.end();
  for (typename Dependencies::const_iterator it = dependencies.begin();
       it != itend; ++it) {
    const SignalBase<Time> &sig = **it;
    dgTDEBUG(15) << "Ask update for " << sig << std::endl;

    if ((sig.getTime() > leader.getTime()) || (sig.needUpdate(t1))) {
      if (updateFromAllChildren)
        continue;
      else {
        res = true;
        break;
      }
    } else {
      if (updateFromAllChildren) {
        res = false;
        break;
      } else
        continue;
    }
  }
  lastAskForUpdate = res;

  dgTDEBUGOUT(15);
  return res;
}

template <class Time>
std::ostream &TimeDependency<Time>::writeGraph(std::ostream &os) const {
  return os;
}

template <class Time>
std::ostream &
TimeDependency<Time>::displayDependencies(std::ostream &os, const int depth,
                                          std::string space, std::string next1,
                                          std::string next2) const {
  leader.SignalBase<Time>::displayDependencies(os, depth, space, next1, next2)
      << " (";
  switch (dependencyType) {
  case ALWAYS_READY:
    os << "A";
    break;
  case BOOL_DEPENDENT:
    os << "ready=" << ((leader.getReady()) ? "TRUE" : "FALSE");
    break;
  case TIME_DEPENDENT:
    os << "t=" << leader.getTime() << " (/" << periodTime << ") ";
    break;
  };
  os << ")"; //<<std::endl;
  {
    const typename Dependencies::const_iterator itend = dependencies.end();
    for (typename Dependencies::const_iterator it = dependencies.begin();
         it != itend; ++it)
      if (depth != 0) {
        os << std::endl;
        std::string ajout = "|";
        std::string ajout2 = "|";
        typename Dependencies::const_iterator it2 = it;
        ++it2;
        if (it2 == dependencies.end()) {
          ajout = "`";
          ajout2 = " ";
        }
        (*it)->displayDependencies(os, depth - 1, space + next2 + "   ", ajout,
                                   ajout2);
      } else {
        os << std::endl << space << "   `-- ...";
        break;
      }
  }
  return os;
}

} // end of namespace dynamicgraph

#undef __TIME_DEPENDENCY_INIT
#endif