filtering stream More...

#include <FilterStream.h>

Inheritance diagram for ers::FilterStream:

Public Member Functions
	FilterStream (Stream *target_ptr, const std::vector< std::string > &include_list, const std::vector< std::string > &exclude_list)
	~FilterStream ()
	destructor
virtual bool	is_accept (const Issue *issue_ptr)
	filter method
virtual void	send (const Issue *issue_ptr)
	send method
virtual void	print_to (std::ostream &stream) const
	FilterStream (Stream *target_ptr, const std::vector< std::string > &include_list, const std::vector< std::string > &exclude_list)
	~FilterStream ()
	destructor
virtual bool	is_accept (const Issue *issue_ptr)
	filter method
virtual void	send (const Issue *issue_ptr)
	send method
virtual void	print_to (std::ostream &stream) const
	FilterStream (Stream *target_ptr, const std::vector< std::string > &include_list, const std::vector< std::string > &exclude_list)
	~FilterStream ()
	destructor
virtual bool	is_accept (const Issue *issue_ptr)
	filter method
virtual void	send (const Issue *issue_ptr)
	send method
virtual void	print_to (std::ostream &stream) const
Public Member Functions inherited from ers::Stream
	Stream ()
	Stream (const Stream &other)
	operator std::string () const
virtual	~Stream ()
virtual Issue *	receive ()
	Receives an issue from the stream.
	Stream ()
	Stream (const Stream &other)
	operator std::string () const
virtual	~Stream ()
virtual Issue *	receive ()
	Receives an issue from the stream.
	Stream ()
	Stream (const Stream &other)
	operator std::string () const
virtual	~Stream ()
virtual Issue *	receive ()
	Receives an issue from the stream.

Static Public Member Functions
static FilterStream *	factory (const std::string &include_str, const ::std::string &exclude_str, const std::string &target_str)
	factory method for partially parse information
static FilterStream *	factory (const std::string &parameters)
	factory method for unparsed information
static FilterStream *	factory (const std::string &include_str, const ::std::string &exclude_str, const std::string &target_str)
static FilterStream *	factory (const std::string &parameters)
static FilterStream *	factory (const std::string &include_str, const ::std::string &exclude_str, const std::string &target_str)
static FilterStream *	factory (const std::string &parameters)

Static Public Attributes
static const char *const	FILTER_STREAM_TAG = "filter"
	tag used to identity this stream
static const char *const	INCLUDE_TAG = "?"
	tag used to mark the start of the include list
static const char *const	EXCLUDE_TAG = "!"
	tag used to mark the start of the exclude list
static const char *const	TARGET_TAG = "@"
	tag used to mark the target stream
static const char *const	SEPARATORS = ","
	separators between include and exclude qualifiers
Static Public Attributes inherited from ers::Stream
static const char *const	NULL_STREAM_KEY = "null"

Protected Member Functions
	FilterStream ()
	FilterStream (const FilterStream &other)
	FilterStream ()
	FilterStream (const FilterStream &other)
	FilterStream ()
	FilterStream (const FilterStream &other)

Protected Attributes
Stream *	m_target_stream_ptr
	chained target stream
std::vector< std::string >	m_include
	include list
std::vector< std::string >	m_exclude
	exclude list

Detailed Description

filtering stream

This stream offers basic filtering capacities It basically hooks up in front of another stream and filters the data output. Filtering is based on two list and include list and and exclude list To be accepted an Issue needs two match two criteria

No qualifier in the issue should match strings in the exclude list
At least one qualifier in the issue should match a string in the include list

If the include list is empty, the second condition is not applied. This stream should only be used for severity levels where filtering makes sense, i.e warning, debugs, etc... The syntax to request a filter stream is the following:
filter:filter:?include_qualifier1,include_qualifier2!exclude_qualifier1,exclude_qualifier2@stream_identifier The stream_identifier can be any stream_key used by the ERS system (including a second filter).

For more information on associating a stream to a severity level, see the documentation on the StreamFactory class.

See also: ers::StreamFactory

Author: Matthias Wiesmann

Version: 1.0

Definition at line 37 of file Event/ers/include/ers/FilterStream.h.

Constructor & Destructor Documentation

◆ FilterStream() [1/9]

ers::FilterStream::FilterStream ( )

protected

Disabled empty constructor

Definition at line 77 of file FilterStream.cxx.

77: ers::Stream() {} // FilterStream

Referenced by factory(), factory(), and FilterStream().

◆ FilterStream() [2/9]

ers::FilterStream::FilterStream ( const FilterStream & other )

protected

Disabled copy constructor

Definition at line 82 of file FilterStream.cxx.

83 : ers::Stream( other ) {} // FilterStream

◆ FilterStream() [3/9]

ers::FilterStream::FilterStream	(	ers::Stream *	target_ptr,
		const std::vector< std::string > &	include_list,
		const std::vector< std::string > &	exclude_list )

Constructor

Parameters

target_ptr	pointer to the target stream, the target pointer is assumed to be allocated on the stack and owned by the current object, i.e it will be deleted upon destruction
include_list	collection of strings, at least one of these strings need to be present in the qualifiers in order for the Issue to be accepted.
exclude_list	collection of strings, no qualifier of the Issue must match those in this collection in order for the Issue to be accepted.

Definition at line 94 of file FilterStream.cxx.

    : ers::Stream() {
  ERS_CHECK_PTR( target_ptr );
  m_target_stream_ptr = target_ptr;
  m_include           = include_list;
  m_exclude           = exclude_list;
} // FilterStream

◆ ~FilterStream() [1/3]

ers::FilterStream::~FilterStream ( )

destructor

Destructor

Definition at line 107 of file FilterStream.cxx.

107{ delete ( m_target_stream_ptr ); } // FilterStream

◆ FilterStream() [4/9]

ers::FilterStream::FilterStream ( )

protected

◆ FilterStream() [5/9]

ers::FilterStream::FilterStream ( const FilterStream & other )

protected

◆ FilterStream() [6/9]

ers::FilterStream::FilterStream	(	Stream *	target_ptr,
		const std::vector< std::string > &	include_list,
		const std::vector< std::string > &	exclude_list )

◆ ~FilterStream() [2/3]

ers::FilterStream::~FilterStream ( )

destructor

◆ FilterStream() [7/9]

ers::FilterStream::FilterStream ( )

protected

◆ FilterStream() [8/9]

ers::FilterStream::FilterStream ( const FilterStream & other )

protected

◆ FilterStream() [9/9]

ers::FilterStream::FilterStream	(	Stream *	target_ptr,
		const std::vector< std::string > &	include_list,
		const std::vector< std::string > &	exclude_list )

◆ ~FilterStream() [3/3]

ers::FilterStream::~FilterStream ( )

destructor

Member Function Documentation

◆ factory() [1/6]

ers::FilterStream * ers::FilterStream::factory	(	const std::string &	include_str,
		const ::std::string &	exclude_str,
		const std::string &	target_str )

static

factory method for partially parse information

Builds a stream out of a set of parameters

Parameters

include_str	string containing all the coma separated include qualifiers
exclude_str	string containing all the coma separated exclude qualifiers
target_str	string containing the key for the target stream, i.e the stream where accepted Issues are sent.

Definition at line 45 of file FilterStream.cxx.

                                                                               {
  ers::Stream* target_stream = ers::StreamFactory::instance()->create_stream( target_str );
  std::vector<std::string> include_list = ers::Core::tokenize( include_str, SEPARATORS );
  std::vector<std::string> exclude_list = ers::Core::tokenize( exclude_str, SEPARATORS );
  return new FilterStream( target_stream, include_list, exclude_list );
} // factory

◆ factory() [2/6]

FilterStream * ers::FilterStream::factory	(	const std::string &	include_str,
		const ::std::string &	exclude_str,
		const std::string &	target_str )

static

◆ factory() [3/6]

FilterStream * ers::FilterStream::factory	(	const std::string &	include_str,
		const ::std::string &	exclude_str,
		const std::string &	target_str )

static

◆ factory() [4/6]

ers::FilterStream * ers::FilterStream::factory ( const std::string & params )

static

factory method for unparsed information

Builds a stream out of a key string. This method parses the string and calls a more specialised version of the factory method.

Parameters

params single string describing the requested filter stream

Returns: pointer to newly heap allocated instance of FilterStream

Definition at line 61 of file FilterStream.cxx.

                                                                   {
  std::string::size_type include_start = params.find( INCLUDE_TAG );
  std::string::size_type exclude_start = params.find( EXCLUDE_TAG );
  std::string::size_type target_start  = params.find( TARGET_TAG );
  std::string            include_str   = params.substr( include_start + 1, exclude_start - 1 );
  std::string            exclude_str =
      params.substr( exclude_start + 1, target_start - exclude_start - 1 );
  std::string target_str = params.substr( target_start + 1 );
  // ERS_DEBUG_0("include: '%s' exclude: '%s' target
  // '%s'",include_str.c_str(),exclude_str.c_str(), target_str.c_str());
  return factory( include_str, exclude_str, target_str );
} // factory

◆ factory() [5/6]

FilterStream * ers::FilterStream::factory ( const std::string & parameters )

static

◆ factory() [6/6]

FilterStream * ers::FilterStream::factory ( const std::string & parameters )

static

◆ is_accept() [1/3]

bool ers::FilterStream::is_accept ( const Issue * issue_ptr )

virtual

filter method

Filtering method This method checks if an Issue is to be accepted or not.

Parameters

issue_ptr the issue to check

Returns: true if the Issue passes filtering, false otherwise.

Definition at line 115 of file FilterStream.cxx.

                                                           {
  ERS_CHECK_PTR( issue_ptr );
  std::string qualifiers = issue_ptr->get_value( ers::Issue::QUALIFIER_LIST_KEY );
  if ( !qualifiers.empty() )
  { // we check if qualifiers are in exclude list
    std::vector<std::string>::const_iterator e_pos;
    for ( e_pos = m_exclude.begin(); e_pos != m_exclude.end(); e_pos++ )
    {
      std::string::size_type conflict = qualifiers.find( *e_pos );
      if ( conflict != std::string::npos ) { return false; } // found conflict
    }                                                        // for
  }                                                          // there are some qualifiers
  if ( !m_include.empty() )
  {
    std::vector<std::string>::const_iterator i_pos;
    for ( i_pos = m_include.begin(); i_pos != m_include.end(); i_pos++ )
    {
      std::string::size_type match = qualifiers.find( *i_pos );
      if ( match != std::string::npos ) { return true; } // found match
    }                                                    // for
    return false;
  } // include list contains items
  return true;
} // is_accept

Referenced by send().

◆ is_accept() [2/3]

virtual bool ers::FilterStream::is_accept ( const Issue * issue_ptr )

virtual

filter method

◆ is_accept() [3/3]

virtual bool ers::FilterStream::is_accept ( const Issue * issue_ptr )

virtual

filter method

◆ print_to() [1/3]

void ers::FilterStream::print_to ( std::ostream & stream ) const

virtual

Prints stream description to stream

Parameters

stream STL target stream

Reimplemented from ers::Stream.

Definition at line 165 of file FilterStream.cxx.

                                                         {
  stream << FILTER_STREAM_TAG << ':';
  std::vector<std::string>::const_iterator i_pos;
  stream << INCLUDE_TAG;
  for ( i_pos = m_include.begin(); i_pos != m_include.end(); i_pos++ )
  {
    if ( i_pos != m_include.begin() ) { stream << SEPARATORS; } // if not first
    stream << *i_pos;
  } // for include
  stream << EXCLUDE_TAG;
  std::vector<std::string>::const_iterator e_pos;
  for ( e_pos = m_exclude.begin(); e_pos != m_exclude.end(); e_pos++ )
  {
    if ( e_pos != m_exclude.begin() ) { stream << SEPARATORS; } // if not first
    stream << *e_pos;
  } // for exclude
  stream << TARGET_TAG;
  stream << *m_target_stream_ptr;
} // print_to

◆ print_to() [2/3]

virtual void ers::FilterStream::print_to ( std::ostream & stream ) const

virtual

Reimplemented from ers::Stream.

◆ print_to() [3/3]

virtual void ers::FilterStream::print_to ( std::ostream & stream ) const

virtual

Reimplemented from ers::Stream.

◆ send() [1/3]

void ers::FilterStream::send ( const Issue * issue_ptr )

virtual

send method

Send method basically calls is_accept to check if the issue is accepted. If this is the case, the send method on the target is called with issue_ptr.

Parameters

issue_ptr pointer to the issue to send.

Reimplemented from ers::Stream.

Definition at line 147 of file FilterStream.cxx.

                                                      {
  ERS_CHECK_PTR( issue_ptr );
  ERS_CHECK_PTR( m_target_stream_ptr );
  if ( is_accept( issue_ptr ) )
  {
    // ERS_DEBUG_3("accepted %s:",issue_ptr->what());
    m_target_stream_ptr->send( issue_ptr );
  }
  else
  {
    // ERS_DEBUG_3("rejected %s:",issue_ptr->what());
  }
} // send