ErrorLogger.h

#ifndef _ERROR_LOGGER_H_
#define _ERROR_LOGGER_H_
#include "mspass/utility/ErrorLogger.h"
#include "mspass/utility/MsPASSError.h"
#include <boost/archive/basic_archive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/serialization.hpp>
#include <list>
#include <unistd.h>
namespace mspass {
namespace utility {
class LogData {
public:
  int job_id; 
  int p_id; 
  std::string algorithm; 
  mspass::utility::ErrorSeverity badness; 
  std::string message; 
  LogData() {};
  LogData(const int jid, const std::string alg,
          const mspass::utility::MsPASSError &merr);
  LogData(const int jid, const std::string alg, const std::string msg,
          const mspass::utility::ErrorSeverity lvl);
  friend std::ostream &operator<<(std::ostream &, LogData &);
 
private:
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & job_id;
    ar & p_id;
    ar & algorithm;
    ar & badness;
    ar & message;
  };
};
class ErrorLogger {
public:
  ErrorLogger() { job_id = 0; };
  ErrorLogger(int job) { job_id = job; };
  ErrorLogger(int job, const std::list<LogData> &messages)
      : job_id(job), allmessages(messages) {};
  ErrorLogger(const ErrorLogger &parent);
  void set_job_id(int jid) { job_id = jid; };
  int get_job_id() { return job_id; };
  int log_error(const mspass::utility::MsPASSError &merr);
  int log_error(const std::string alg, const std::string mess,
                const mspass::utility::ErrorSeverity level);
 
  int log_verbose(const std::string alg, const std::string mess);
  std::list<LogData> get_error_log() const { return allmessages; };
  int size() const { return allmessages.size(); };
  void clear() { allmessages.clear(); };
  ErrorLogger &operator=(const ErrorLogger &parent);
  ErrorLogger &operator+=(const ErrorLogger &parent);
  std::list<LogData> worst_errors() const;
 
private:
  int job_id;
  std::list<LogData> allmessages;
  friend boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & job_id;
    ar & allmessages;
  };
};
 
template <typename Tdata> bool data_are_valid(const Tdata &d) {
  if (d.dead())
    return false;
  std::list<LogData> welog;
  welog = d.elog.worst_errors();
  /*The return will be empty if there are no errors logged*/
  if (welog.size() <= 0)
    return true;
  LogData ld;
  /* Worst errors can return a list of multiple entries.  For
  fatal or invalid id should never be more than one, but this is
  a clean way to extract the first member of the list if it isn't empty*/
  ld = *(welog.begin());
  if (ld.badness == ErrorSeverity::Fatal ||
      ld.badness == ErrorSeverity::Invalid)
    return false;
  else
    return true;
}
} // namespace utility
} // namespace mspass
#endif