JLoggerMessage.hh

Go to the documentation of this file.

#ifndef __JDB_JLOGGERMESSAGE__
#define __JDB_JLOGGERMESSAGE__
 
#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include <iomanip>
 
#include "JSystem/JDateAndTime.hh"
 
#include "JNet/JTag.hh"
 
#include "JLang/JException.hh"
#include "JLang/JManip.hh"
 
#include "JLogger/JMessageLogger.hh"
#include "JDAQ/JDAQTags.hh"
 
#include "JDatalogString.hh"
 
 
namespace JDB {}
namespace JPP { using namespace JDB; }
 
namespace JDB {
 
  using JLANG::JFileOpenException;
  using JLANG::JParseError;
  using JSYSTEM::JDateAndTime;
 
 
  /**
   * Auxiliary data structure for logger message.
   */
  struct JLoggerMessage {
    /**
     * Default constructor.
     */
    JLoggerMessage()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  datalog       data log
     */
    JLoggerMessage(const JDatalogString& datalog)
    {
      using namespace std;
      using namespace JPP;
      using namespace KM3NETDAQ;
 
      if (datalog.source == MESSAGE_TAG) {
 
        this->tag = datalog.source;
 
        istringstream is(datalog.data);
 
        if (is >> this->datim >> this->ip >> this->nickname >> this->level) {
          
          this->datim.set(datalog.utc / 1000, (float) (datalog.utc%1000) * 1.0e-3, true);
 
          while (is.peek() != EOF && isspace((char) is.peek())) { is.ignore(1); }
 
          getline(is, this->data);
 
        } else {
 
          THROW(JParseError, "Invalid string " << datalog.source << " " << datalog.data);
        }
 
      } else {
 
        THROW(JParseError, "Invalid source " << datalog.source);
      }
    }
 
 
    /**
     * Get match.
     *
     * \param  message       message
     * \return               true if message matches; else false
     */
    bool match(const JLoggerMessage& message) const
    {
      using namespace std;
 
      if (!message.tag     .empty() && message.tag      != tag)                 { return false; }
      if (!message.process .empty() && message.process  != process)             { return false; }
      if (!message.nickname.empty() && message.nickname != nickname)            { return false; }
      if (!message.ip      .empty() && message.ip       != ip)                  { return false; }
      if (!message.fullname.empty() && message.fullname != fullname)            { return false; }
      if (!message.level   .empty() && message.level    != level)               { return false; }
      if (!message.data    .empty() && !regex_match(data, regex(message.data))) { return false; }
 
      return true;
    }
 
 
    /**
     * Check if message has date and time.
     *
     * \return               true if messages has date and time; else false
     */
    bool hasTime() const
    {
      using namespace JPP;
 
      return (tag != DISPTAG_Born.toString() &&
              tag != DISPTAG_Died.toString());
    }
 
 
    /**
     * Get UTC time.
     *
     * \return               time [ms]
     */
    long int getTime() const
    {
      return (long int) 1000 * (long int) datim.getTime() + (long int) 500;
    }
 
 
    /**
     * Read message from input.
     *
     * \param  in            input stream
     * \param  object        message
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JLoggerMessage& object)
    {
      using namespace JPP;
 
      object = JLoggerMessage();
 
      in >> object.file_name
         >> object.tag
         >> object.process;
 
      if (object.tag != DISPTAG_Born.toString() &&
          object.tag != DISPTAG_Died.toString()) {
 
        in >> object.datim
           >> object.ip
           >> object.nickname
           >> object.level;
 
        while (in.peek() != EOF && isspace((char) in.peek())) { in.ignore(1); }
 
        return getline(in, object.data);
 
      } else {
 
        return in >> object.fullname;
      }
    }
 
 
    /**
     * Write message to output.
     *
     * \param  out           output stream
     * \param  object        message
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JLoggerMessage& object)
    {
      using namespace std;
      using namespace JPP;
 
      if (object.tag != DISPTAG_Born.toString() &&
          object.tag != DISPTAG_Died.toString()) {
 
        out << LEFT(8) 
            << object.tag       << ' ' << right;
        out << object.datim     << ' ';
        //out << object.getTime() << ' ';
        //out << object.ip        << ' ';
        out << object.nickname  << ' ';
        //out << object.level     << ' ';
        out << object.data;
 
      } else {
 
        out << object.tag       << ' ';
        //out << object.process   << ' ';
        out << object.fullname;
      }
 
      return out;
    }
 
 
    std::string  file_name;
    std::string  tag;
    std::string  process;
    JDateAndTime datim;
    std::string  ip;
    std::string  nickname;
    std::string  fullname;
    std::string  level;
    std::string  data;
  };
}
 
#endif