ers::FormattedStandardStream< Device > Struct Template Reference

#include <FormattedStandardStream.hpp>

Inheritance diagram for ers::FormattedStandardStream< Device >:

Collaboration diagram for ers::FormattedStandardStream< Device >:

Classes
struct	Fields

Public Member Functions
	FormattedStandardStream ()=default
	FormattedStandardStream (const std::string &format)
void	write (const Issue &issue) override
Public Member Functions inherited from ers::OutputStream
virtual	~OutputStream ()
	Sends the issue into this stream.

Private Member Functions
void	report (std::ostream &out, const Issue &issue)

Static Private Member Functions
static std::string	get_file_name (const std::string &param)
static std::string	get_format (const std::string &param)

Private Attributes
std::vector< format::Token >	m_tokens

Static Private Attributes
static Fields	s_supported_fields

Additional Inherited Members
Protected Member Functions inherited from ers::OutputStream
	OutputStream ()
OutputStream &	chained ()
virtual bool	isNull () const

Detailed Description

template<class Device>
struct ers::FormattedStandardStream< Device >

Definition at line 36 of file FormattedStandardStream.hpp.

Constructor & Destructor Documentation

FormattedStandardStream() [1/2]

template<class Device >

ers::FormattedStandardStream< Device >::FormattedStandardStream ( )

default

FormattedStandardStream() [2/2]

template<class Device >

ers::FormattedStandardStream< Device >::FormattedStandardStream ( const std::string & format )

explicit

This constructor creates a new formatted output stream. The format parameter is a comma separated list of tokens that defines the which attributes of the issues will be printed as well as their order. Here is the list of supported tokens: "severity, time, position, context, pid, tid, cwd, function, line, cause, stack, parameters, qualifiers, user"

Parameters

format

a list of issue attributes that have to be printed for each issue

Definition at line 65 of file FormattedStandardStream.hxx.

  : Device( get_file_name( param ) )
{
    std::string format = get_format( param );
    
    size_t offset = 0;
    size_t index = std::string::npos;
    do {
        index = format.find( DELIMITER, offset );
        std::string token = format.substr( offset, index - offset );
    std::map<std::string,ers::format::Token>::iterator it = s_supported_fields.find( token );
    if ( it != s_supported_fields.end() )
        m_tokens.push_back( it->second );
        
        offset += token.size() + 1;
    } while ( index != std::string::npos );
}

Member Function Documentation

get_file_name()

template<class Device >

std::string ers::FormattedStandardStream< Device >::get_file_name ( const std::string & param )

staticprivate

Definition at line 42 of file FormattedStandardStream.hxx.

{
    std::string first_token = param.substr( 0, param.find( ',' ) );
    std::map<std::string,ers::format::Token>::iterator it = s_supported_fields.find( first_token );
    if ( it != s_supported_fields.end() )
        return "";
    else
        return first_token;
}

get_format()

template<class Device >

std::string ers::FormattedStandardStream< Device >::get_format ( const std::string & param )

staticprivate

Definition at line 54 of file FormattedStandardStream.hxx.

{
    std::string first_token = param.substr( 0, param.find( ',' ) );
    std::map<std::string,ers::format::Token>::iterator it = s_supported_fields.find( first_token );
    if ( it != s_supported_fields.end() )
        return param;
    else
        return param.substr( first_token.size() < param.size() ? first_token.size() + 1 : param.size() );
}

report()

template<class Device >

void ers::FormattedStandardStream< Device >::report ( std::ostream & out, const Issue & issue )

private

Definition at line 85 of file FormattedStandardStream.hxx.

{
    for ( size_t i = 0; i < m_tokens.size(); i++ )
    {
    switch ( m_tokens[i] )
        {
        case format::Severity:
        out << ers::to_string( issue.severity() );
                break;
        case format::Time:
        out << issue.time<std::chrono::microseconds>() << " ";
                break;
        case format::Position:
        out << "[" << issue.context().position( ) << "]";
                break;
        case format::Function:
        out << issue.context().function_name();
                break;
        case format::Line:
        out << issue.context().line_number();
                break;
        case format::Text:
        out << issue.message();
                break;
        case format::Parameters:
        {
            out << FIELD_SEPARATOR << "Parameters = ";
            for ( ers::string_map::const_iterator it = issue.parameters().begin(); it != issue.parameters().end(); ++it )
            {
            out << "'" << it->first << "=" << it->second << "' ";
            }
        }
        break;
        case format::Qualifiers:
        {
            out << FIELD_SEPARATOR << "Qualifiers = ";
            for ( std::vector<std::string>::const_iterator it = issue.qualifiers().begin(); it != issue.qualifiers().end(); ++it )
            {
            out << "'" << *it << "' ";
            }
        }
        break;
        case format::Context:
        out << FIELD_SEPARATOR << "host = " << issue.context().host_name()
            << FIELD_SEPARATOR << "user = " << issue.context().user_name()
                       << " (" << issue.context().user_id() << ")"
            << FIELD_SEPARATOR << "process id = " << issue.context().process_id()
            << FIELD_SEPARATOR << "thread id = " << issue.context().thread_id()
            << FIELD_SEPARATOR << "process wd = " << issue.context().cwd();
        break;
        case format::Host:
        out << FIELD_SEPARATOR << "host = " << issue.context().host_name();
                break;
            case format::User:
        out << FIELD_SEPARATOR << "user = " << issue.context().user_name()
                       << " (" << issue.context().user_id() << ")";
                break;
            case format::PID:
        out << FIELD_SEPARATOR << "process id = " << issue.context().process_id();
                break;
            case format::TID:
        out << FIELD_SEPARATOR << "thread id = " << issue.context().thread_id();
                break;
            case format::CWD:
        out << FIELD_SEPARATOR << "process wd = " << issue.context().cwd();
        break;
        case format::Stack:
        {
            std::vector<std::string> stack = issue.context().stack();
            for( size_t i = 0; i < stack.size(); i++ )
            {
            out << FIELD_SEPARATOR << "#" << std::setw(3) << std::left << i << stack[i];
            }
        } 
        break;
        case format::Cause:
        if ( issue.cause() )
        {
            out << FIELD_SEPARATOR << "was caused by: ";
            report( out, *issue.cause() );
        }
                break;
            default:
                break;
    }
    out << " ";
    }
    out << std::endl;
}

write()

template<class Device >

void ers::FormattedStandardStream< Device >::write ( const Issue & issue )

overridevirtual

Implements ers::OutputStream.

Definition at line 177 of file FormattedStandardStream.hxx.

{
    report( device().stream(), issue );
    chained().write( issue );
}

Member Data Documentation

m_tokens

template<class Device >

std::vector<format::Token> ers::FormattedStandardStream< Device >::m_tokens

private

Definition at line 64 of file FormattedStandardStream.hpp.

s_supported_fields

template<class Device >

ers::FormattedStandardStream< Device >::Fields ers::FormattedStandardStream< Device >::s_supported_fields

staticprivate

Definition at line 63 of file FormattedStandardStream.hpp.

---

The documentation for this struct was generated from the following files:

• /github/workspace/dunedaq/sourcecode/ers/include/ers/internal/FormattedStandardStream.hpp
• /github/workspace/dunedaq/sourcecode/ers/include/ers/internal/FormattedStandardStream.hxx