Issue.cpp

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 src/Issue.cxx to src/Issue.cpp).
 *
 * Original copyright:
 * Copyright (C) 2001-2020 CERN for the benefit of the ATLAS collaboration.
 * Licensed under the Apache License, Version 2.0.
 */
 
/*
 *  Issue.cxx
 *  ers
 *
 *  Created by Matthias Wiesmann on 26.11.04.
 *  Modified by Serguei Kolos on 02.08.05.
 *  Copyright 2004 CERN. All rights reserved.
 *
 */
 
#include <csignal>
#include <iomanip>
#include <sstream>
#include <algorithm>
#include <ctime>
#include <time.h>
 
#include <ers/Issue.hpp>
#include <ers/IssueFactory.hpp>
#include <ers/OutputStream.hpp>
#include <ers/StandardStreamOutput.hpp>
#include <ers/ers.hpp>
#include <ers/internal/Util.hpp>
 
using namespace ers;
 
ERS_DECLARE_ISSUE( ers, StdIssue, ERS_EMPTY, ERS_EMPTY )
 
namespace
{
    int get_default_qualifiers( std::vector<std::string> & qualifiers )
    {
        static const char * environment = ::getenv( "DUNEDAQ_ERS_QUALIFIERS" );
        if ( environment )
        {
        ers::tokenize( environment, ",", qualifiers );
        }
        return 1;
    }
    
    void add_default_qualifiers( Issue & issue )
    {
        static std::vector<std::string> qualifiers;
        // static int _unused_ = get_default_qualifiers( qualifiers );
        get_default_qualifiers( qualifiers );
    for ( std::vector<std::string>::const_iterator it = qualifiers.begin(); it != qualifiers.end(); ++it )
        {
        issue.add_qualifier( *it );
        }
    }    
}
 
Issue::Issue( const Issue & other )
  : std::exception( other ),
    m_cause( other.m_cause.get() ? other.m_cause->clone() : 0 ),
    m_context( other.m_context->clone() ),
    m_message( other.m_message ),
    m_qualifiers( other.m_qualifiers ),
    m_severity( other.m_severity ),
    m_time( other.m_time ),
    m_values( other.m_values )
{ ; }
 

Issue::Issue(   const Context & context,
        const std::string & message )
  : m_context( context.clone() ),
    m_message( message ),
    m_severity( ers::Error ),
    m_time( system_clock::now() )
{
    add_qualifier( m_context->package_name() );
    add_default_qualifiers( *this );
}

Issue::Issue(   const Context & context,
                const std::exception & cause )
  : m_context( context.clone() ),
    m_severity( ers::Error ),
    m_time( system_clock::now() )
{
    const Issue * issue = dynamic_cast<const Issue *>( &cause );
    m_cause.reset( issue ? issue->clone() : new StdIssue( ERS_HERE, cause.what() ) );
    add_qualifier( m_context->package_name() );
    add_default_qualifiers( *this );
}

Issue::Issue(   const Context & context,
        const std::string & message,
        const std::exception & cause )
  : m_context( context.clone() ),
    m_message( message ),
    m_severity( ers::Error ),
    m_time( system_clock::now() )
{
    const Issue * issue = dynamic_cast<const Issue *>( &cause );
    m_cause.reset( issue ? issue->clone() : new StdIssue( ERS_HERE, cause.what() ) );
    add_qualifier( m_context->package_name() );
    add_default_qualifiers( *this );
}
 
Issue::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 )
  : m_cause( cause ),
    m_context( context.clone() ),
    m_message( message ),
    m_qualifiers( qualifiers ),
    m_severity( severity ),
    m_time( time ),
    m_values( parameters )
{ ; }
 
ers::Issue::~Issue() noexcept
{ ; }
 
std::time_t 
ers::Issue::time_t() const
{
    return system_clock::to_time_t(m_time);
}
 
void 
ers::Issue::get_value( const std::string & key, const char * & value ) const
{
    string_map::const_iterator it = m_values.find(key);
    if ( it != m_values.end() )
    {
    value = it->second.c_str();
    }
    else
    {
        throw ers::NoValue( ERS_HERE, key );
    }
}
 
void 
ers::Issue::get_value( const std::string & key, std::string & value ) const
{
    string_map::const_iterator it = m_values.find(key);
    if ( it != m_values.end() )
    {
    value = it->second;
    }
    else
    {
        throw ers::NoValue( ERS_HERE, key );
    }
}

void 
Issue::add_qualifier( const std::string & qualifier )
{
    if ( std::find( m_qualifiers.begin(), m_qualifiers.end(), qualifier ) == m_qualifiers.end() ) {
        m_qualifiers.push_back( qualifier );
    }
}
 
ers::Severity
Issue::set_severity( ers::Severity severity ) const
{
    ers::Severity old_severity = m_severity;
    m_severity = severity;
    return old_severity;
}

void
Issue::prepend_message( const std::string & msg )
{
    m_message = msg + m_message;
}

void
Issue::wrap_message( const std::string & begin, const std::string & end )
{
    m_message = begin + m_message + end;
}
 
namespace ers {
  
    std::ostream & operator<<( std::ostream & out, const ers::Issue & issue )
    {
        return StandardStreamOutput::print( out, issue, ers::verbosity_level() );
    }
}