signal-caster.h

// -*- c++-mode -*-
// Copyright 2010 François Bleibel Thomas Moulard, Olivier Stasse
//

#ifndef DYNAMIC_GRAPH_SIGNAL_CASTER_HH
#define DYNAMIC_GRAPH_SIGNAL_CASTER_HH
#include <map>
#include <typeinfo>
#include <vector>

#include <boost/any.hpp>
#include <boost/format.hpp>
#include <boost/function/function1.hpp>
#include <boost/function/function2.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/tuple/tuple.hpp>

#include "dynamic-graph/exception-signal.h"
#include <dynamic-graph/dynamic-graph-api.h>

namespace dynamicgraph {
class DYNAMIC_GRAPH_DLLAPI SignalCaster {
public:
  virtual ~SignalCaster();
  static void destroy();
  typedef boost::function2<void, const boost::any &, std::ostream &>
      displayer_type;
  typedef boost::function1<boost::any, std::istringstream &> caster_type;
  typedef boost::function2<void, const boost::any &, std::ostream &>
      tracer_type;

  static SignalCaster *getInstance(void);
  void disp(const boost::any &object, std::ostream &os);
  void trace(const boost::any &object, std::ostream &os);
  boost::any cast(const std::type_info &, std::istringstream &iss);
  void registerCast(const std::type_info &type, displayer_type displayer,
                    caster_type caster, tracer_type tracer);
  void unregisterCast(const std::type_info &type);
  bool existsCast(const std::type_info &type) const;
  std::vector<std::string> listTypenames() const;

private:
  typedef boost::tuple<displayer_type, caster_type, tracer_type>
      cast_functions_type;

  cast_functions_type &getCast(const std::string &type_name);

  std::map<std::string, cast_functions_type> functions_;

  std::map<std::string, const std::type_info *> type_info_;

private:
  explicit SignalCaster();
  static SignalCaster *instance_;
};

class DYNAMIC_GRAPH_DLLAPI SignalCastRegisterer {
public:
  inline SignalCastRegisterer(const std::type_info &type,
                              SignalCaster::displayer_type displayer,
                              SignalCaster::caster_type caster,
                              SignalCaster::tracer_type tracer) {
    SignalCaster::getInstance()->registerCast(type, displayer, caster, tracer);
  }
};

template <typename T> void signal_disp(const T &value, std::ostream &os) {
  SignalCaster::getInstance()->disp(value, os);
}

template <typename T> T signal_cast(std::istringstream &iss) {
  return boost::any_cast<T>(SignalCaster::getInstance()->cast(typeid(T), iss));
}

template <typename T> void signal_trace(const T &value, std::ostream &os) {
  SignalCaster::getInstance()->trace(value, os);
}
} // end of namespace dynamicgraph.

#endif