dataLog.hpp

/* $Id$ */

#ifndef KERNEL_DATA_LOG_HPP
#define KERNEL_DATA_LOG_HPP

#include <string>
#include <sstream>
#include <fstream>
#include <list>
#include <iomanip>

#include <kernel/threads.hpp>

namespace jafar {

  namespace kernel {


    class Loggable
    {
     public:
      virtual void log() = 0;
      virtual ~Loggable() {}
    };


    class LoggerTask
    {
     private:
      kernel::VariableCondition<size_t> cond;
      std::list<Loggable*> queue;
      bool stopping;
      boost::thread *task_thread;
      int niceness;

     private:
      void task();

     public:
      LoggerTask(int niceness = 0);
      void push(Loggable *loggable);
      void stop(bool wait = true);
      void join();
    };


    class LoggableString: public Loggable
    {
     private:
      std::ostream &logStream;
      std::string content;
     public:
       LoggableString(std::ostream & logStream, std::string const & content):
        logStream(logStream), content(content) {}
       virtual void log();
    };


    class LoggableClose: public kernel::Loggable
    {
     private:
      std::fstream *logStream;
      std::ofstream *logoStream;
     public:
      LoggableClose(std::fstream & logStream): logStream(&logStream), logoStream(NULL) {}
      LoggableClose(std::ofstream & logoStream): logStream(NULL), logoStream(&logoStream) {}
      virtual void log() {
        if (logStream && logStream->is_open()) logStream->close();
        if (logoStream && logoStream->is_open()) logoStream->close();
      }
    };


    class DataLogger;
    class DataLoggable;

    class DataLoggable {

    private:

      DataLogger* p_logger;

      void setLogger(DataLogger& logger);

    protected:

      DataLoggable();
      virtual ~DataLoggable();

      virtual void writeLogHeader(DataLogger& log) const = 0;

      virtual void addMembersToLog(DataLogger& log) const {}

      virtual void writeLogData(DataLogger& log) const = 0;

      virtual void writeLogStats(DataLogger& log) const {}


      friend class DataLogger;

    }; // class Loggable



    class DataLogger {

    private:

      std::ofstream logStream;
      std::ostringstream logHeaderLine;
      std::ostringstream logContent;
      bool logStarted;

      char separator;

      char commentPrefix;

      unsigned int nbColumns;

      LoggerTask *loggerTask;

      typedef std::list<DataLoggable const*> LoggablesList;
      LoggablesList loggables;

      typedef std::list<DataLogger*> LoggersList;
      LoggersList slaves;

      void write(std::ostringstream & content);

    public:

      DataLogger(std::string const& logFilename_,
        char separator_ = '\t',
        char commentPrefix_ = '#');

      void setLoggerTask(LoggerTask *loggerTask) { this->loggerTask = loggerTask; }

      void writeComment(std::string const& comment_);

      void writeCurrentDate();

      void addLoggable(DataLoggable& loggable_);

      void removeLoggable(DataLoggable const& loggable_);

      void addSlaveLogger(DataLogger& logger_);

      void log();
      void logStats();

      void writeLegend(std::string const& legend_);

      void writeLegendTokens(std::string const& legendTokens_, std::string const& tokenSep_ = " ");

      template <typename T>
      void writeData(T const& d) {
        logContent << d << separator;
      }
      void writeNewLine() {
        logContent << std::endl;
      }

      void writeNaN() {
        logContent << "NaN" << separator;
      }

      template <class Vec>
      void writeDataVector(Vec const& v) {
        for (std::size_t i = 0 ; i < v.size() ; ++i)
          writeData(v[i]);
      }

    }; // class DataLogger

  }
}

#endif // KERNEL_DATA_LOG_HPP