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 <sstream>
#include <vector>

#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>

#include <dynamic-graph/config.hh>

namespace dynamicgraph {
class LoggerStream {
public:
  virtual void write(const char *c) = 0;
};

class LoggerIOStream : public LoggerStream {
public:
  LoggerIOStream(std::ostream &os) : os_(os) {}
  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