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


Class template channel_severity_filter_actor



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

template<typename ChannelT, typename SeverityT, 
         typename ChannelFallbackT = fallback_to_none, 
         typename SeverityFallbackT = fallback_to_none, 
         typename ChannelOrderT = less, 
         typename SeverityCompareT = greater_equal, 
         typename AllocatorT = use_std_allocator, 
         template< typename > class ActorT = phoenix::actor> 
class channel_severity_filter_actor : public phoenix::actor< channel_severity_filter_terminal< ChannelT, SeverityT, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator > >
  // types
  typedef channel_severity_filter_terminal< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, ChannelOrderT, SeverityCompareT, AllocatorT > terminal_type;             // Terminal type. 
  typedef ActorT< terminal_type >                                                                                                                   base_type;                 // Base actor type. 
  typedef terminal_type::channel_value_type                                                                                                         channel_value_type;        // Channel attribute value type. 
  typedef terminal_type::channel_fallback_policy                                                                                                    channel_fallback_policy;   // Channel fallback policy. 
  typedef terminal_type::severity_value_type                                                                                                        severity_value_type;       // Severity level attribute value type. 
  typedef terminal_type::severity_fallback_policy                                                                                                   severity_fallback_policy;  // Severity level fallback policy. 

  // member classes/structs/unions

  // An auxiliary pseudo-reference to implement insertion through subscript
  // operator.

  class subscript_result {
    // construct/copy/destruct
    subscript_result(channel_severity_filter_actor &, 
                     channel_value_type const &);
    void operator=(severity_value_type const &);

  // construct/copy/destruct
  explicit channel_severity_filter_actor(base_type const &);
  channel_severity_filter_actor(channel_severity_filter_actor const &);

  // public member functions
  this_type & set_default(bool);
  this_type & add(channel_value_type const &, severity_value_type const &);
  subscript_result operator[](channel_value_type const &);


channel_severity_filter_actor public construct/copy/destruct

  1. explicit channel_severity_filter_actor(base_type const & act);
    Initializing constructor.
  2. channel_severity_filter_actor(channel_severity_filter_actor const & that);
    Copy constructor.

channel_severity_filter_actor public member functions

  1. this_type & set_default(bool def);
    Sets the default function result.
  2. this_type & add(channel_value_type const & channel, 
                    severity_value_type const & severity);
    Adds a new element to the mapping.
  3. subscript_result operator[](channel_value_type const & channel);
    Alternative interface for adding a new element to the mapping.