## Class template channel_severity_filter_terminal

boost::log::expressions::channel_severity_filter_terminal

## Synopsis

    // 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 = std::allocator< void > >
    class channel_severity_filter_terminal {
    public:
      // types
      typedef void              _is_boost_log_terminal;    // Internal typedef for type categorization.
      typedef bool              result_type;               // Function result type.
      typedef ChannelT          channel_value_type;        // Channel attribute value type.
      typedef ChannelFallbackT  channel_fallback_policy;   // Channel fallback policy.
      typedef SeverityT         severity_value_type;       // Severity level attribute value type.
      typedef SeverityFallbackT severity_fallback_policy;  // Severity level fallback policy.

      // member classes/structs/unions

      // Channel visitor.
      template<typename ArgT>
      struct channel_visitor {
        // types
        typedef void result_type;

        // construct/copy/destruct
        channel_visitor(channel_severity_filter_terminal const &, ArgT, bool &);

        // public member functions
        result_type operator()(channel_value_type const &) const;
      };

      // Severity level visitor.

      struct severity_visitor {
        // types
        typedef void result_type;

        // construct/copy/destruct
        severity_visitor(channel_severity_filter_terminal const &,
                         severity_value_type const &, bool &);

        // public member functions
        result_type operator()(severity_value_type const &) const;
      };

      // construct/copy/destruct
      channel_severity_filter_terminal(attribute_name const &,
                                       attribute_name const &,
                                       channel_fallback_policy const & = channel_fallback_policy(),
                                       severity_fallback_policy const & = severity_fallback_policy(),
                                       ChannelOrderT const & = ChannelOrderT(),
                                       SeverityCompareT const & = SeverityCompareT());

      // public member functions
      void add(channel_value_type const &, severity_value_type const &);
      void set_default(bool);
      template<typename ContextT> result_type operator()(ContextT const &) const;

      // private member functions
      template<typename ArgT>
        void visit_channel(channel_value_type const &, ArgT const &, bool &) const;
      void visit_severity(severity_value_type const &,
                          severity_value_type const &, bool &) const;
    };

## Description

### `channel_severity_filter_terminal` public construct/copy/destruct

1.     channel_severity_filter_terminal(attribute_name const & channel_name,
                                        attribute_name const & severity_name,
                                        channel_fallback_policy const & channel_fallback = channel_fallback_policy(),
                                        severity_fallback_policy const & severity_fallback = severity_fallback_policy(),
                                        ChannelOrderT const & channel_order = ChannelOrderT(),
                                        SeverityCompareT const & severity_compare = SeverityCompareT());

   Initializing constructor.

### `channel_severity_filter_terminal` public member functions

1.     void add(channel_value_type const & channel,
                severity_value_type const & severity);

   Adds a new element to the mapping.

2.     void set_default(bool def);

   Sets the default result of the predicate.

3.     template<typename ContextT> result_type operator()(ContextT const & ctx) const;

   Invokation operator.

### `channel_severity_filter_terminal` private member functions

1.     template<typename ArgT>
         void visit_channel(channel_value_type const & channel, ArgT const & arg,
                            bool & res) const;

   Visits channel name.

2.     void visit_severity(severity_value_type const & left,
                           severity_value_type const & right, bool & res) const;

   Visits severity level.