ers::StreamManager Class Reference

This class manages and provides access to ERS streams. More...

#include <StreamManager.hpp>

Collaboration diagram for ers::StreamManager:

Public Member Functions
	~StreamManager ()
void	debug (const Issue &issue, int level)
	sends an Issue to the debug stream
void	error (const Issue &issue)
	sends an issue to the error stream
void	fatal (const Issue &issue)
	sends an issue to the fatal stream
void	information (const Issue &issue)
	sends an issue to the information stream
void	log (const Issue &issue)
	sends an issue to the log stream
void	warning (const Issue &issue)
	sends an issue to the warning stream
void	add_receiver (const std::string &stream, const std::string &filter, ers::IssueReceiver *receiver)
void	add_receiver (const std::string &stream, const std::initializer_list< std::string > &params, ers::IssueReceiver *receiver)
void	remove_receiver (ers::IssueReceiver *receiver)
void	add_output_stream (ers::severity severityseverity, ers::OutputStream *new_stream)
void	report_issue (ers::severity type, const Issue &issue)

Static Public Member Functions
static StreamManager &	instance ()
	return the singleton

Private Member Functions
	StreamManager ()
OutputStream *	setup_stream (ers::severity severityseverity)
OutputStream *	setup_stream (const std::vector< std::string > &streams)

Private Attributes
PluginManager	m_plugin_manager
std::mutex	m_mutex
std::list< std::shared_ptr< InputStream > >	m_in_streams
std::shared_ptr< OutputStream >	m_init_streams [ers::Fatal+1]
	array of pointers to streams per severity
std::shared_ptr< OutputStream >	m_out_streams [ers::Fatal+1]
	array of pointers to streams per severity

Friends
class	StreamInitializer
class	ers::LocalStream
class	ers::ErrorHandler
template<class>
class	SingletonCreator

Detailed Description

This class manages and provides access to ERS streams.

The StreamManager class is responsible for creating and handling all the ERS streams used by an application. It implements the singleton pattern and handles a table of the different stream attached to each severity. When issues occur they are dispatched to an appropriate stream by the singleton instance of this class. Users should not use this class directly. In order to report issues users should use global functions declared in the ers namespace.

Author

Serguei Kolos

See also

ers::debug

ers::error

ers::fatal

ers::infomation

ers::log

ers::warning

Definition at line 69 of file StreamManager.hpp.

Constructor & Destructor Documentation

~StreamManager()

ers::StreamManager::~StreamManager

(

)

Destructor - basic cleanup

Definition at line 175 of file StreamManager.cpp.

{
  ;
}

StreamManager()

ers::StreamManager::StreamManager ( )

private

Private constructor - can not be called by user code, use the instance() method instead

See also

instance()

Definition at line 165 of file StreamManager.cpp.

{
  for (short ss = ers::Debug; ss <= ers::Fatal; ++ss) {
    m_init_streams[ss] = std::make_shared<StreamInitializer>(*this);
    m_out_streams[ss] = m_init_streams[ss];
  }
}

Member Function Documentation

add_output_stream()

void ers::StreamManager::add_output_stream	(	ers::severity	severity,
		ers::OutputStream *	new_stream )

Definition at line 181 of file StreamManager.cpp.

{
  std::shared_ptr<OutputStream> head = m_out_streams[severity];
  if (head && !head->isNull()) {
    OutputStream* parent = head.get();
    for (OutputStream* stream = parent; !stream->isNull(); parent = stream, stream = &parent->chained())
      ;
 
    parent->chained(new_stream);
  } else {
    m_out_streams[severity] = std::shared_ptr<OutputStream>(new_stream);
  }
}

add_receiver() [1/2]

void ers::StreamManager::add_receiver	(	const std::string &	stream,
		const std::initializer_list< std::string > &	params,
		ers::IssueReceiver *	receiver )

Definition at line 206 of file StreamManager.cpp.

{
  InputStream* in = ers::StreamFactory::instance().create_in_stream(stream, params);
  in->set_receiver(receiver);
 
  std::scoped_lock lock(m_mutex);
  m_in_streams.push_back(std::shared_ptr<InputStream>(in));
}

add_receiver() [2/2]

void ers::StreamManager::add_receiver	(	const std::string &	stream,
		const std::string &	filter,
		ers::IssueReceiver *	receiver )

Definition at line 196 of file StreamManager.cpp.

{
  InputStream* in = ers::StreamFactory::instance().create_in_stream(stream, filter);
  in->set_receiver(receiver);
 
  std::scoped_lock lock(m_mutex);
  m_in_streams.push_back(std::shared_ptr<InputStream>(in));
}

debug()

void ers::StreamManager::debug	(	const Issue &	issue,
		int	level )

sends an Issue to the debug stream

Sends an issue to the debug stream

Parameters

issue	the Issue to send
level	the debug level.

Definition at line 311 of file StreamManager.cpp.

{
  if (Configuration::instance().debug_level() >= level) {
    ers::severity old_severity = issue.set_severity(ers::Severity(ers::Debug, level));
    m_out_streams[ers::Debug]->write(issue);
    issue.set_severity(old_severity);
  }
}

error()

void ers::StreamManager::error

(

const Issue &

issue

)

sends an issue to the error stream

Sends an Issue to the error stream

Parameters

issue

Definition at line 301 of file StreamManager.cpp.

{
  report_issue(ers::Error, issue);
} // error

fatal()

void ers::StreamManager::fatal

(

const Issue &

issue

)

sends an issue to the fatal stream

Sends an Issue to the fatal error stream

Parameters

issue

Definition at line 324 of file StreamManager.cpp.

{
  report_issue(ers::Fatal, issue);
}

information()

void ers::StreamManager::information

(

const Issue &

issue

)

sends an issue to the information stream

Sends an issue to the info stream

Parameters

issue

the Issue to send

Definition at line 342 of file StreamManager.cpp.

{
  report_issue(ers::Information, issue);
}

instance()

ers::StreamManager & ers::StreamManager::instance ( )

static

return the singleton

This method returns the singleton instance. It should be used for every operation on the factory.

Returns

a reference to the singleton instance

Singleton instance

Definition at line 153 of file StreamManager.cpp.

{
  static ers::StreamManager* instance = ers::SingletonCreator<ers::StreamManager>::create();
 
  return *instance;
} // instance

log()

void ers::StreamManager::log

(

const Issue &

issue

)

sends an issue to the log stream

Sends an issue to the log stream

Parameters

issue

the Issue to send

Definition at line 351 of file StreamManager.cpp.

{
  report_issue(ers::Log, issue);
}

remove_receiver()

void ers::StreamManager::remove_receiver

(

ers::IssueReceiver *

receiver

)

Definition at line 218 of file StreamManager.cpp.

{
  std::scoped_lock lock(m_mutex);
  for (std::list<std::shared_ptr<InputStream>>::iterator it = m_in_streams.begin(); it != m_in_streams.end();) {
    if ((*it)->m_receiver == receiver)
      m_in_streams.erase(it++);
    else
      ++it;
  }
}

report_issue()

void ers::StreamManager::report_issue	(	ers::severity	type,
		const Issue &	issue )

Sends an Issue to an appropriate stream

Parameters

type
issue

Definition at line 290 of file StreamManager.cpp.

{
  ers::severity old_severity = issue.set_severity(type);
  m_out_streams[type]->write(issue);
  issue.set_severity(old_severity);
} // error

setup_stream() [1/2]

ers::OutputStream * ers::StreamManager::setup_stream ( const std::vector< std::string > & streams )

private

Definition at line 258 of file StreamManager.cpp.

{
  size_t cnt = 0;
  ers::OutputStream* main = 0;
  for (; cnt < streams.size(); ++cnt) {
    main = ers::StreamFactory::instance().create_out_stream(streams[cnt]);
    if (main)
      break;
  }
 
  if (!main) {
    return 0;
  }
 
  ers::OutputStream* head = main;
  for (++cnt; cnt < streams.size(); ++cnt) {
    ers::OutputStream* chained = ers::StreamFactory::instance().create_out_stream(streams[cnt]);
 
    if (chained) {
      head->chained(chained);
      head = chained;
    }
  }
 
  return main;
}

setup_stream() [2/2]

ers::OutputStream * ers::StreamManager::setup_stream ( ers::severity severity )

private

Definition at line 230 of file StreamManager.cpp.

{
  std::string config = get_stream_description(severity);
  std::vector<std::string> streams;
  try {
    parse_stream_definition(config, streams);
  } catch (ers::BadConfiguration& ex) {
    ERS_INTERNAL_ERROR("Configuration for the \"" << severity
                                                  << "\" stream is invalid. "
                                                     "Default configuration will be used.");
  }
 
  ers::OutputStream* main = setup_stream(streams);
 
  if (!main) {
    std::vector<std::string> default_streams;
    try {
      parse_stream_definition(DefaultOutputStreams[severity], default_streams);
      main = setup_stream(default_streams);
    } catch (ers::BadConfiguration& ex) {
      ERS_INTERNAL_ERROR("Can not configure the \"" << severity << "\" stream because of the following issue {" << ex
                                                    << "}");
    }
  }
  return (main ? main : new ers::NullStream());
}

warning()

void ers::StreamManager::warning

(

const Issue &

issue

)

sends an issue to the warning stream

Sends an Issue to the warning stream

Parameters

issue

the issue to send

Definition at line 333 of file StreamManager.cpp.

{
  report_issue(ers::Warning, issue);
}

Friends And Related Symbol Documentation

ers::ErrorHandler

friend class ers::ErrorHandler

friend

Definition at line 73 of file StreamManager.hpp.

ers::LocalStream

friend class ers::LocalStream

friend

Definition at line 72 of file StreamManager.hpp.

SingletonCreator

template<class>

friend class SingletonCreator

friend

Definition at line 75 of file StreamManager.hpp.

StreamInitializer

friend class StreamInitializer

friend

Definition at line 71 of file StreamManager.hpp.

Member Data Documentation

m_in_streams

std::list<std::shared_ptr<InputStream> > ers::StreamManager::m_in_streams

private

Definition at line 114 of file StreamManager.hpp.

m_init_streams

std::shared_ptr<OutputStream> ers::StreamManager::m_init_streams[ers::Fatal+1]

private

array of pointers to streams per severity

Definition at line 115 of file StreamManager.hpp.

m_mutex

std::mutex ers::StreamManager::m_mutex

private

Definition at line 113 of file StreamManager.hpp.

m_out_streams

std::shared_ptr<OutputStream> ers::StreamManager::m_out_streams[ers::Fatal+1]

private

array of pointers to streams per severity

Definition at line 116 of file StreamManager.hpp.

m_plugin_manager

PluginManager ers::StreamManager::m_plugin_manager

private

Definition at line 112 of file StreamManager.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/ers/include/ers/StreamManager.hpp
• /github/workspace/dunedaq/sourcecode/ers/src/StreamManager.cpp