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 51 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 77 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 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 "";
  else
    return first_token;
}

get_format()

template<class Device>

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

staticprivate

Definition at line 66 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 97 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 176 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 82 of file FormattedStandardStream.hpp.

s_supported_fields

template<class Device>

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

staticprivate

Definition at line 81 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