ers::FilterStream Class Reference

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
Public Member Functions inherited from ers::Stream
	Stream ()
	Stream (const Stream &other)
	operator std::string () const
virtual	~Stream ()
virtual void	send (const Issue *i)
	Sends an issue into the stream.
virtual Issue *	receive ()
	Receives an issue from the stream.
virtual void	print_to (std::ostream &stream) const

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 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)

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 38 of file FilterStream.h.

Constructor & Destructor Documentation

FilterStream() [1/3]

ers::FilterStream::FilterStream ( )

protected

Disabled empty constructor

Definition at line 72 of file FilterStream.cxx.

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

Referenced by factory().

FilterStream() [2/3]

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

protected

Disabled copy constructor

Definition at line 79 of file FilterStream.cxx.

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

FilterStream() [3/3]

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 92 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()

ers::FilterStream::~FilterStream

(

)

destructor

Destructor

Definition at line 105 of file FilterStream.cxx.

                               {
    delete(m_target_stream_ptr) ; 
} // FilterStream

Member Function Documentation

factory() [1/2]

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 43 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/2]

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 57 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

is_accept()

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

print_to()

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 162 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

send()

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

Member Data Documentation

EXCLUDE_TAG

const char *const ers::FilterStream::EXCLUDE_TAG = "!"

static

tag used to mark the start of the exclude list

Definition at line 48 of file FilterStream.h.

FILTER_STREAM_TAG

const char *const ers::FilterStream::FILTER_STREAM_TAG = "filter"

static

tag used to identity this stream

Tag used to identify the stream

Definition at line 46 of file FilterStream.h.

INCLUDE_TAG

const char *const ers::FilterStream::INCLUDE_TAG = "?"

static

tag used to mark the start of the include list

Definition at line 47 of file FilterStream.h.

m_exclude

std::vector<std::string> ers::FilterStream::m_exclude

protected

exclude list

Definition at line 42 of file FilterStream.h.

Referenced by FilterStream().

m_include

std::vector<std::string> ers::FilterStream::m_include

protected

include list

Definition at line 41 of file FilterStream.h.

Referenced by FilterStream().

m_target_stream_ptr

Stream* ers::FilterStream::m_target_stream_ptr

protected

chained target stream

Definition at line 40 of file FilterStream.h.

Referenced by FilterStream().

SEPARATORS

const char *const ers::FilterStream::SEPARATORS = ","

static

separators between include and exclude qualifiers

Definition at line 50 of file FilterStream.h.

Referenced by factory().

TARGET_TAG

const char *const ers::FilterStream::TARGET_TAG = "@"

static

tag used to mark the target stream

Definition at line 49 of file FilterStream.h.

---

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

• FilterStream.h
• FilterStream.cxx