entity.h

// -*- mode: c++ -*-
// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
// JRL, CNRS/AIST.
//
 
#ifndef DYNAMIC_GRAPH_ENTITY_H
#define DYNAMIC_GRAPH_ENTITY_H
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/exception-factory.h>
#include <dynamic-graph/logger.h>
#include <dynamic-graph/signal-array.h>
#include <dynamic-graph/signal-base.h>
 
#include <boost/noncopyable.hpp>
#include <dynamic-graph/fwd.hh>
#include <iosfwd>
#include <map>
#include <sstream>
#include <string>
 
//      // your class here
#define DYNAMIC_GRAPH_ENTITY_DECL()                                      \
 public:                                                                 \
  virtual const std::string &getClassName() const { return CLASS_NAME; } \
  static const std::string CLASS_NAME
 
namespace dynamicgraph {
class DYNAMIC_GRAPH_DLLAPI Entity : private boost::noncopyable {
 public:
  typedef std::map<std::string, SignalBase<sigtime_t> *> SignalMap;
  typedef std::map<const std::string, command::Command *> CommandMap_t;
 
  explicit Entity(const std::string &name);
  virtual ~Entity();
 
  const std::string &getName() const { return name; }
  virtual const std::string &getClassName() const {
    static std::string ret("Entity");
    return ret;
  }
  virtual std::string getDocString() const;
 
  bool hasSignal(const std::string &signame) const;
 
  SignalBase<sigtime_t> &getSignal(const std::string &signalName);
 
  const SignalBase<sigtime_t> &getSignal(const std::string &signalName) const;
 
  std::ostream &displaySignalList(std::ostream &os) const;
 
  virtual std::ostream &writeGraph(std::ostream &os) const;
 
  virtual std::ostream &writeCompletionList(std::ostream &os) const;
 
  virtual void display(std::ostream &os) const;
 
  virtual SignalBase<sigtime_t> *test() { return 0; }
 
  virtual void test2(SignalBase<sigtime_t> *) { return; }
 
  const std::string &getCommandList() const;
 
  CommandMap_t getNewStyleCommandMap();
  command::Command *getNewStyleCommand(const std::string &cmdName);
 
  SignalMap getSignalMap() const;
 
 
  Logger &logger() { return logger_; };
  Logger const &logger() const { return logger_; };
 
  void sendMsg(const std::string &msg, MsgType t = MSG_TYPE_INFO,
               const std::string &lineId = "");
 
  void setLoggerVerbosityLevel(LoggerVerbosity lv) { logger_.setVerbosity(lv); }
 
  LoggerVerbosity getLoggerVerbosityLevel() { return logger_.getVerbosity(); }
 
  bool setTimeSample(double t) { return logger_.setTimeSample(t); }
 
  double getTimeSample() { return logger_.getTimeSample(); }
 
  bool setStreamPrintPeriod(double t) {
    return logger_.setStreamPrintPeriod(t);
  }
 
  double getStreamPrintPeriod() { return logger_.getStreamPrintPeriod(); }
 
 
 protected:
  void addCommand(const std::string &name, command::Command *command);
 
  void entityRegistration();
  void entityDeregistration();
 
  void signalRegistration(const SignalArray<sigtime_t> &signals);
  void signalDeregistration(const std::string &name);
 
  std::string name;
  SignalMap signalMap;
  CommandMap_t commandMap;
  Logger logger_;
};
 
DYNAMIC_GRAPH_DLLAPI std::ostream &operator<<(std::ostream &os,
                                              const dynamicgraph::Entity &ent);
}  // end of namespace dynamicgraph
 
#endif