real-time-logger-def.h

// -*- mode: c++ -*-
// Copyright 2018, Joseph Mirabel LAAS-CNRS
//
 
#ifndef DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
#define DYNAMIC_GRAPH_LOGGER_REAL_TIME_DEF_H
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <dynamic-graph/config.hh>
#include <sstream>
#include <vector>
 
namespace dynamicgraph {
class LoggerStream {
 public:
  virtual void write(const char *c) = 0;
};
 
class LoggerIOStream : public LoggerStream {
 public:
  LoggerIOStream(std::ostream &os) : os_(os) {}
  virtual ~LoggerIOStream() {}
  virtual void write(const char *c) { os_ << c; }
 
 private:
  std::ostream &os_;
};
typedef boost::shared_ptr<LoggerStream> LoggerStreamPtr_t;
 
class RealTimeLogger;
 
class RTLoggerStream {
 public:
  inline RTLoggerStream(RealTimeLogger *logger, std::ostream &os)
      : ok_(logger != NULL), logger_(logger), os_(os) {}
  template <typename T>
  inline RTLoggerStream &operator<<(T t) {
    if (ok_) os_ << t;
    return *this;
  }
  inline RTLoggerStream &operator<<(std::ostream &(*pf)(std::ostream &)) {
    if (ok_) os_ << pf;
    return *this;
  }
 
  inline ~RTLoggerStream();
 
  inline bool isNull() { return !ok_; }
 
 private:
  const bool ok_;
  RealTimeLogger *logger_;
  std::ostream &os_;
};
 
class DYNAMIC_GRAPH_DLLAPI RealTimeLogger {
 public:
  static RealTimeLogger &instance();
 
  static void destroy();
 
  RealTimeLogger(const std::size_t &bufferSize);
 
  inline void clearOutputStreams() { outputs_.clear(); }
 
  inline void addOutputStream(const LoggerStreamPtr_t &os) {
    outputs_.push_back(os);
  }
 
  bool spinOnce();
 
  RTLoggerStream front();
 
  RTLoggerStream emptyStream() { return RTLoggerStream(NULL, oss_); }
 
  inline void frontReady() {
    backIdx_ = (backIdx_ + 1) % buffer_.size();
    wmutex.unlock();
  }
 
  inline bool empty() const { return frontIdx_ == backIdx_; }
 
  inline bool full() const {
    return ((backIdx_ + 1) % buffer_.size()) == frontIdx_;
  }
 
  inline std::size_t size() const {
    if (frontIdx_ <= backIdx_)
      return backIdx_ - frontIdx_;
    else
      return backIdx_ + buffer_.size() - frontIdx_;
  }
 
  inline std::size_t getBufferSize() { return buffer_.size(); }
 
  ~RealTimeLogger();
 
 private:
  struct Data {
    std::stringbuf buf;
  };
 
  std::vector<LoggerStreamPtr_t> outputs_;
  std::vector<Data *> buffer_;
  std::size_t frontIdx_;
  std::size_t backIdx_;
  std::ostream oss_;
 
  boost::mutex wmutex;
  std::size_t nbDiscarded_;
 
  struct thread;
 
  static RealTimeLogger *instance_;
  static thread *thread_;
};
 
RTLoggerStream::~RTLoggerStream() {
  if (ok_) {
    os_ << std::ends;
    logger_->frontReady();
  }
}
 
}  // end of namespace dynamicgraph
 
#endif