Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Function channel_severity_filter

boost::log::expressions::channel_severity_filter

Synopsis

// In header: <boost/log/expressions/predicates/channel_severity_filter.hpp>


template<typename ChannelT, typename SeverityT> 
  channel_severity_filter_actor< ChannelT, SeverityT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_name const & severity_name);
template<typename SeverityT, typename ChannelDescriptorT, 
         template< typename > class ActorT> 
  channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const & channel_keyword, 
                          attribute_name const & severity_name);
template<typename ChannelT, typename SeverityDescriptorT, 
         template< typename > class ActorT> 
  channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_keyword< SeverityDescriptorT, ActorT > const & severity_keyword);
template<typename ChannelDescriptorT, typename SeverityDescriptorT, 
         template< typename > class ActorT> 
  channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const & channel_keyword, 
                          attribute_keyword< SeverityDescriptorT, ActorT > const & severity_keyword);
template<typename SeverityT, typename ChannelT, typename ChannelFallbackT, 
         typename ChannelTagT, template< typename > class ActorT> 
  channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const & channel_placeholder, 
                          attribute_name const & severity_name);
template<typename ChannelT, typename SeverityT, typename SeverityFallbackT, 
         typename SeverityTagT, template< typename > class ActorT> 
  channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, greater_equal, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const & severity_placeholder);
template<typename ChannelT, typename ChannelFallbackT, typename ChannelTagT, 
         typename SeverityT, typename SeverityFallbackT, 
         typename SeverityTagT, template< typename > class ActorT> 
  channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, greater_equal, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const & channel_placeholder, 
                          attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const & severity_placeholder);
template<typename ChannelT, typename SeverityT, typename SeverityCompareT> 
  channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_name const & severity_name, 
                          SeverityCompareT const & severity_compare);
template<typename SeverityT, typename ChannelDescriptorT, 
         template< typename > class ActorT, typename SeverityCompareT> 
  channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const & channel_keyword, 
                          attribute_name const & severity_name, 
                          SeverityCompareT const & severity_compare);
template<typename ChannelT, typename SeverityDescriptorT, 
         template< typename > class ActorT, typename SeverityCompareT> 
  channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_keyword< SeverityDescriptorT, ActorT > const & severity_keyword, 
                          SeverityCompareT const & severity_compare);
template<typename ChannelDescriptorT, typename SeverityDescriptorT, 
         template< typename > class ActorT, typename SeverityCompareT> 
  channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const & channel_keyword, 
                          attribute_keyword< SeverityDescriptorT, ActorT > const & severity_keyword, 
                          SeverityCompareT const & severity_compare);
template<typename SeverityT, typename ChannelT, typename ChannelFallbackT, 
         typename ChannelTagT, template< typename > class ActorT, 
         typename SeverityCompareT> 
  channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const & channel_placeholder, 
                          attribute_name const & severity_name, 
                          SeverityCompareT const & severity_compare);
template<typename ChannelT, typename SeverityT, typename SeverityFallbackT, 
         typename SeverityTagT, template< typename > class ActorT, 
         typename SeverityCompareT> 
  channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const & severity_placeholder, 
                          SeverityCompareT const & severity_compare);
template<typename ChannelT, typename ChannelFallbackT, typename ChannelTagT, 
         typename SeverityT, typename SeverityFallbackT, 
         typename SeverityTagT, template< typename > class ActorT, 
         typename SeverityCompareT> 
  channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const & channel_placeholder, 
                          attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const & severity_placeholder, 
                          SeverityCompareT const & severity_compare);
template<typename ChannelT, typename SeverityT, typename SeverityCompareT, 
         typename ChannelOrderT> 
  channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_name const & severity_name, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);
template<typename SeverityT, typename ChannelDescriptorT, 
         template< typename > class ActorT, typename SeverityCompareT, 
         typename ChannelOrderT> 
  channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const & channel_keyword, 
                          attribute_name const & severity_name, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);
template<typename ChannelT, typename SeverityDescriptorT, 
         template< typename > class ActorT, typename SeverityCompareT, 
         typename ChannelOrderT> 
  channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_keyword< SeverityDescriptorT, ActorT > const & severity_keyword, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);
template<typename ChannelDescriptorT, typename SeverityDescriptorT, 
         template< typename > class ActorT, typename SeverityCompareT, 
         typename ChannelOrderT> 
  channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const & channel_keyword, 
                          attribute_keyword< SeverityDescriptorT, ActorT > const & severity_keyword, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);
template<typename SeverityT, typename ChannelT, typename ChannelFallbackT, 
         typename ChannelTagT, template< typename > class ActorT, 
         typename SeverityCompareT, typename ChannelOrderT> 
  channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const & channel_placeholder, 
                          attribute_name const & severity_name, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);
template<typename ChannelT, typename SeverityT, typename SeverityFallbackT, 
         typename SeverityTagT, template< typename > class ActorT, 
         typename SeverityCompareT, typename ChannelOrderT> 
  channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_name const & channel_name, 
                          attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const & severity_placeholder, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);
template<typename ChannelT, typename ChannelFallbackT, typename ChannelTagT, 
         typename SeverityT, typename SeverityFallbackT, 
         typename SeverityTagT, template< typename > class ActorT, 
         typename SeverityCompareT, typename ChannelOrderT> 
  channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > 
  channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const & channel_placeholder, 
                          attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const & severity_placeholder, 
                          SeverityCompareT const & severity_compare, 
                          ChannelOrderT const & channel_order);

Description

The function generates a filtering predicate that checks the severity levels of log records in different channels. The predicate will return true if the record severity level is not less than the threshold for the channel the record belongs to.


PrevUpHomeNext