signal-base.h

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

#ifndef DYNAMIC_GRAPH_SIGNAL_BASE_H
#define DYNAMIC_GRAPH_SIGNAL_BASE_H
#include <boost/noncopyable.hpp>
#include <sstream>
#include <string>
#include <typeinfo>

#include <dynamic-graph/exception-signal.h>
#include <dynamic-graph/fwd.hh>

namespace dynamicgraph {

template <class Time> class SignalBase : public boost::noncopyable {
public:
  explicit SignalBase(std::string name = "")
      : name(name), signalTime(0), ready(false) {}

  virtual ~SignalBase() {}

  virtual const Time &getTime() const { return signalTime; }

  virtual void setTime(const Time &t) { signalTime = t; }

  const bool &getReady() const { return ready; }

  const std::string &getName() const { return name; }

  void getClassName(std::string &aClassName) const {
    aClassName = typeid(this).name();
  }

  virtual void setPeriodTime(const Time &) {}

  virtual Time getPeriodTime() const { return 1; }



  virtual void addDependency(const SignalBase<Time> &) {}

  virtual void removeDependency(const SignalBase<Time> &) {}

  virtual void clearDependencies() {}

  virtual bool needUpdate(const Time &) const { return ready; }

  inline void setReady(const bool sready = true) { ready = sready; }

  virtual std::ostream &writeGraph(std::ostream &os) const { return os; }

  virtual std::ostream &displayDependencies(std::ostream &os, const int = -1,
                                            std::string space = "",
                                            std::string next1 = "",
                                            std::string = "") const {
    os << space << next1 << "-- ";
    display(os);
    return os;
  }



  /* Plug the arg-signal on the <this> object. Plug-in is always
   * a descending operation (the actual <this> object will call the arg-signal
   * and not the opposite).
   */
  virtual void plug(SignalBase<Time> *sigarg) {
    DG_THROW ExceptionSignal(
        ExceptionSignal::PLUG_IMPOSSIBLE,
        "Plug-in operation not possible with this signal. ",
        "(while trying to plug %s on %s).", sigarg->getName().c_str(),
        this->getName().c_str());
  }

  virtual void unplug() {
    DG_THROW ExceptionSignal(
        ExceptionSignal::PLUG_IMPOSSIBLE,
        "Plug-in operation not possible with this signal. ",
        "(while trying to unplug %s).", this->getName().c_str());
  }

  virtual bool isPlugged() const { return false; }

  virtual SignalBase<Time> *getPluged() const { return NULL; }

  virtual void setConstantDefault() {
    DG_THROW ExceptionSignal(
        ExceptionSignal::PLUG_IMPOSSIBLE,
        "Plug-in operation not possible with this signal. ",
        "(while trying to save %s).", this->getName().c_str());
  }



  /* Generic set function. Should be reimplemented by the specific
   * Signal.  Sets a signal value
   */
  virtual void set(std::istringstream &) {
    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
                             "Set operation not possible with this signal. ",
                             "(while trying to set %s).",
                             this->getName().c_str());
  }

  virtual void get(std::ostream &) const {
    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
                             "Get operation not possible with this signal. ",
                             "(while trying to get %s).",
                             this->getName().c_str());
  }

  virtual inline void recompute(const Time &) {
    DG_THROW ExceptionSignal(
        ExceptionSignal::SET_IMPOSSIBLE,
        "Recompute operation not possible with this signal. ",
        "(while trying to recompute %s).", this->getName().c_str());
  }

  virtual void trace(std::ostream &) const {
    DG_THROW ExceptionSignal(ExceptionSignal::SET_IMPOSSIBLE,
                             "Trace operation not possible with this signal. ",
                             "(while trying to trace %s).",
                             this->getName().c_str());
  }



  virtual std::ostream &display(std::ostream &os) const {
    os << "Sig:" << name;
    return os;
  }

  std::string shortName() const {
    std::istringstream iss(name);
    const int SIZE = 128;
    char buffer[SIZE];
    while (iss.good()) {
      iss.getline(buffer, SIZE, ':');
    }
    const std::string res(buffer);
    return res;
  }


  virtual void ExtractNodeAndLocalNames(std::string &LocalName,
                                        std::string &NodeName) const {
    std::string fullname = this->getName();

    size_t IdxPosLocalName = fullname.rfind(":");
    LocalName = fullname.substr(IdxPosLocalName + 1,
                                fullname.length() - IdxPosLocalName + 1);
    size_t IdxPosNodeNameStart = fullname.find("(");
    size_t IdxPosNodeNameEnd = fullname.find(")");
    NodeName = fullname.substr(IdxPosNodeNameStart + 1,
                               IdxPosNodeNameEnd - IdxPosNodeNameStart - 1);
  }


  virtual void checkCompatibility() {
    DG_THROW ExceptionSignal(ExceptionSignal::PLUG_IMPOSSIBLE,
                             "Abstract signal not compatible with anything.",
                             "(while trying to plug <%s>).",
                             this->getName().c_str());
  }

protected:
  std::string name;
  Time signalTime;
  bool ready;
};

template <class Time>
std::ostream &operator<<(std::ostream &os, const SignalBase<Time> &sig) {
  return sig.display(os);
}
} // end of namespace dynamicgraph.

#endif