Issue.hpp

Go to the documentation of this file.

/*
 *  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 <map>
#include <string>
#include <iostream>
#include <sstream>
#include <memory>
#include <chrono>
#include <list>
 
#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