logger.hpp

#ifndef STATEOBSERVATIONLOGGER_H
#define STATEOBSERVATIONLOGGER_H
 
#include <map>
#include <stdexcept>
#include <string>
#include <typeinfo>
 
#include <state-observation/api.h>
#include <state-observation/tools/definitions.hpp>
 
namespace stateObservation
{
namespace tools
{
class STATE_OBSERVATION_DLLAPI Logger
{
public:
  Logger();
  virtual ~Logger();

  template<typename T>
  void record(const T * address, const std::string & filename = std::string(""));
  template<typename T>
  void record(const T & reference, const std::string & filename = std::string(""));

  template<typename T>
  void updateAddress(const void * oldAddress, const T * newAddress);

  void setPath(const std::string & path);

  template<typename T>
  void push(const T & reference);
 
  template<typename T>
  void push(const T * address);

  void push();
 
  const IndexedMatrixArray & getRecord(const void * address) const;
 
  IndexedMatrixArray & getRecord(const void * address);

  void save(bool clear = false, bool append = false);

  void clearTracking();

  void clearLogs();
 
protected:
  struct log_s
  {
 
    IndexedMatrixArray array;
    std::string filename;
    const std::type_info * type;
 
    log_s(const std::string & newfilename) : type(0x0)
    {
      filename = newfilename;
    }
 
    template<typename T>
    void setType()
    {
      type = &typeid(T);
    }
  };
 
  typedef std::map<const void *, log_s> Tmap;
  typedef std::pair<const void *, log_s> Tpair;
 
  void update_(const Tmap::iterator & i);
 
  std::string path_;
  std::map<const void *, log_s> logs_;
  Matrix scalar_;
 
private:
};
} // namespace tools
} // namespace stateObservation
 
#include <state-observation/tools/logger.hxx>
 
#endif // STATEOBSERVATIONLOGGER_H