Issue.hpp

Go to the documentation of this file.

/*
 * DUNE DAQ modification notice:
 * This file has been modified from the original ATLAS ers source for the DUNE DAQ project.
 * Fork baseline commit: 8267df82a4f6fe6bf02c4014923eba19eddc4614 (2020-04-14).
 * Renamed since fork: yes (from ers/Issue.h to include/ers/Issue.hpp).
 *
 * Original copyright:
 * Copyright (C) 2001-2020 CERN for the benefit of the ATLAS collaboration.
 * Licensed under the Apache License, Version 2.0.
 */
 
/*
 *  Issue.h
 *  ers
 *
 *  Created by Matthias Wiesmann on 08.12.04.
 *  Modified by Serguei Kolos on 02.08.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#ifndef ERS_ISSUE_H
#define ERS_ISSUE_H
 
#include <math.h>
#include <stdio.h>
#include <string.h>
 
#include <chrono>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <sstream>
#include <string>
 
#include <ers/IssueFactory.hpp>
#include <ers/LocalContext.hpp>
#include <ers/Severity.hpp>

 
using std::chrono::system_clock;
 
namespace ers {
class OutputStream;
 
typedef std::map<std::string, std::string> string_map;
 
using inheritance_type = std::list<std::string>;
 
template<class T>
class IssueRegistrator
{
public:
  IssueRegistrator() { ers::IssueFactory::instance().register_issue(T::get_uid(), create); }
 
private:
  static ers::Issue* create(const Context& context) { return new T(context); }
};

class Issue : public std::exception
{
  friend class IssueFactory;
 
public:
  Issue(const Context& context, const std::string& message = std::string());
 
  Issue(const Context& context, const std::exception& cause);
 
  Issue(const Context& context, const std::string& message, const std::exception& cause);
 
  Issue(const Issue& other);
 
  virtual ~Issue() noexcept;
 
  virtual Issue* clone() const = 0;
 
  virtual const char* get_class_name() const = 0; 
 
  virtual inheritance_type get_class_inheritance() const = 0; 
 
  virtual void raise() const = 0; 
 
  void add_qualifier(const std::string& qualif); 
 
  const Issue* cause() const  { return m_cause.get(); }
 
  const Context& context() const  { return *(m_context.get()); }
 
  const std::string& message() const  { return m_message; }
 
  const std::vector<std::string>& qualifiers() const  { return m_qualifiers; }
 
  const string_map& parameters() const  { return m_values; }
 
  ers::Severity severity() const  { return m_severity; }
 
  template<class Precision = std::chrono::seconds>
  std::string time(const std::string& format = "%Y-%b-%d %H:%M:%S", bool isUTC = false) const;

  template<class Precision>
  std::string localtime(const std::string& format = "%Y-%b-%d %H:%M:%S") const
  {
    return time<Precision>(format, false);
  }

  template<class Precision>
  std::string gmtime(const std::string& format = "%Y-%b-%d %H:%M:%S") const
  {
    return time<Precision>(format, true);
  }
 
  std::time_t time_t() const; 
 
  const system_clock::time_point& ptime() const  { return m_time; }
 
  const char* what() const noexcept  { return m_message.c_str(); }
 
  ers::Severity set_severity(ers::Severity severity) const;
 
  void wrap_message(const std::string& begin, const std::string& end);
 
protected:
  Issue(Severity severity,
        const system_clock::time_point& time,
        const ers::Context& context,
        const std::string& message,
        const std::vector<std::string>& qualifiers,
        const std::map<std::string, std::string>& parameters,
        const ers::Issue* cause = 0);

  template<typename T>
  void get_value(const std::string& key, T& value) const;
  void get_value(const std::string& key, const char*& value) const;
  void get_value(const std::string& key, std::string& value) const;

  template<typename T>
  void set_value(const std::string& key, T value);
 
  void set_message(const std::string& message) { m_message = message; }
 
  void prepend_message(const std::string& message);
 
  static auto _get_inheritance()
  {
    inheritance_type chain;
    chain.push_back("ers::Issue");
    return chain;
  }
 
private:
  Issue& operator=(const Issue& other) = delete;
 
  std::unique_ptr<const Issue> m_cause;  
  std::unique_ptr<Context> m_context;    
  std::string m_message;                 
  std::vector<std::string> m_qualifiers; 
  mutable Severity m_severity;           
  system_clock::time_point m_time;       
  string_map m_values;                   
};
 
std::ostream&
operator<<(std::ostream&, const ers::Issue&);
 
} // ers
 
#include <ers/internal/IssueDeclarationMacro.hpp>
 
ERS_DECLARE_ISSUE(ers, NoValue, "value for the \"" << key << "\" key is not set ", ((std::string)key))
 
template<typename T>
void
ers::Issue::get_value(const std::string& key, T& value) const
{
  string_map::const_iterator it = m_values.find(key);
  if (it == m_values.end()) {
    throw ers::NoValue(ERS_HERE, key);
  }
  std::istringstream in(it->second);
  in >> value;
}
 
template<typename T>
void
ers::Issue::set_value(const std::string& key, T value)
{
  std::ostringstream out;
  out << value;
  m_values[key] = out.str();
}
 
template<class Precision>
std::string
ers::Issue::time(const std::string& format, bool isUTC) const
{
  static const int width(::log10(Precision::period::den));
 
  std::time_t t = time_t();
  std::tm tm = isUTC ? *gmtime_r(&t, &tm) : *localtime_r(&t, &tm);
 
  char buff[128];
  std::strftime(buff, 128 - 16, format.c_str(), &tm);
 
  auto c = std::chrono::duration_cast<Precision>(m_time.time_since_epoch()).count();
  double frac = c - (double)t * Precision::period::den;
  sprintf(buff + strlen(buff), ",%0*.0f", width, frac);
 
  return buff;
}
 
#endif