# Expressions

Andrey Semashev

21.07.2012

The header contains implementation of a generic attribute placeholder in template expressions.

An attribute value extraction terminal

ThisT(ContextT)remove_cv< typename remove_reference< typename phoenix::result_of::env< ContextT >::type >::type >::type env_type::args_type unspecified boost::result_of< cv_value_extractor_type(attribute_name const &, typename fusion::result_of::at_c< args_type, 0 >::type) >::type Internal typedef for type categorization. void Attribute tag type. TagT Attribute value type. value_extractor_type::value_type Fallback policy type. value_extractor_type::fallback_policy result< `this_type`(ContextT const &) >::type

The operator extracts attribute value

result< const `this_type`(ContextT const &) >::type

The operator extracts attribute value

attribute_name

Attribute value name

fallback_policy const &

Fallback policy

`attribute_name const &`

Initializing constructor

`attribute_name const &``U const &`

Initializing constructor

template< typename > class

An attribute value extraction terminal actor

Attribute tag type. TagT Fallback policy. FallbackPolicyT Base terminal type. `attribute_terminal`< T, fallback_policy, tag_type > Attribute value type. terminal_type::value_type Base actor type. ActorT< terminal_type > Expression with cached attribute name. `attribute_actor`< value_type, fallback_to_none, tag_type, ActorT > Expression with cached attribute name. `attribute_actor`< value_type, fallback_to_throw, tag_type, ActorT > attribute_name

The attribute name

fallback_policy const &

Fallback policy

or_none_result_type Generates an expression that extracts the attribute value or a default value. or_throw_result_type Generates an expression that extracts the attribute value or throws an exception. `attribute_actor`< value_type, fallback_to_default< DefaultT >, tag_type, ActorT > `DefaultT const &`Generates an expression that extracts the attribute value or a default value. `base_type const &`Initializing constructor. ``attribute_actor`< AttributeValueT > `attribute_name const &`

The function generates a terminal node in a template expression. The node will extract the value of the attribute with the specified name and type.

` ``attribute_actor`< AttributeValueT, fallback_to_none, TagT > `attribute_name const &`

The function generates a terminal node in a template expression. The node will extract the value of the attribute with the specified name and type.

`

Andrey Semashev

21.07.2012

The header contains forward declaration of a generic attribute placeholder in template expressions.

Andrey Semashev

13.07.2012

The header contains a filter function object definition.

Log record filter function wrapper.

Default filter, always returns `true`. bool result_type `attribute_value_set const &` Result type. bool result_type `attribute_value_set const &

Attribute values of the log record.

`

Filtering operator.

`true` if the log record passes the filter, `false` otherwise.

void

Resets the filter to the default. The default filter always returns `true`.

void``filter` &`

Swaps two filters

Default constructor. Creates a filter that always returns `true`.

``filter` const &`

Copy constructor

``filter` &&`

Move constructor. The moved-from filter is left in an unspecified state.

`FunT &&`

Initializing constructor. Creates a filter which will invoke the specified function object.

`filter` &``filter` &&`

Move assignment. The moved-from filter is left in an unspecified state.

`filter` &``filter` const &`

Copy assignment.

`filter` & `FunT const &`

Initializing assignment. Sets the specified function object to the filter.

`void``filter` &```filter` &``

Andrey Semashev

13.07.2012

The header contains a formatter function object definition.

Log record formatter function wrapper.

Result type. void Character type. CharT Output stream type. basic_formatting_ostream< char_type > result_type `record_view const &

A log record to format.

``stream_type &

A stream to put the formatted characters to.

`

Formatting operator.

void

Resets the formatter to the default. The default formatter only outputs message text.

void``basic_formatter` &`

Swaps two formatters

Default constructor. Creates a formatter that only outputs log message.

``basic_formatter` const &`

Copy constructor

``this_type` &&`

Move constructor. The moved-from formatter is left in an unspecified state.

`FunT &&`

Initializing constructor. Creates a formatter which will invoke the specified function object.

`basic_formatter` &``this_type` &&`

Move assignment. The moved-from formatter is left in an unspecified state.

`basic_formatter` &``this_type` const &`

Copy assignment.

`basic_formatter` & `FunT &&`

Initializing assignment. Sets the specified function object to the formatter.

`basic_formatter`< char > `basic_formatter`< wchar_t > `void ``basic_formatter`< CharT > &```basic_formatter`< CharT > &``

Andrey Semashev

10.11.2012

The header includes all template expression formatters.

Andrey Semashev

18.11.2012

The header contains implementation of C-style character decorators. boost::log::expressions::pattern_replacer< CharT >

A character decorator implementation that escapes all non-prontable and non-ASCII characters in the output with C-style escape sequences.

Result type. base_type::result_type Character type. base_type::char_type String type. base_type::string_type result_type `string_type &``typename string_type::size_type0` Applies string replacements starting from the specified position. Default constructor. unspecified

C-style decorator generator object. The decorator replaces characters with specific meaning in C language with the corresponding escape sequences. The generator provides `operator[]` that can be used to construct the actual decorator. For example:

`c_decor[ stream << attr< std::string >("MyAttr") ]`

For wide-character formatting there is the similar `wc_decor` decorator generator object.

unspecified unspecified

C-style decorator generator object. Acts similarly to `c_decor`, except that `c_ascii_decor` also converts all non-ASCII and non-printable ASCII characters, except for space character, into C-style hexadecimal escape sequences. The generator provides `operator[]` that can be used to construct the actual decorator. For example:

`c_ascii_decor[ stream << attr< std::string >("MyAttr") ]`

For wide-character formatting there is the similar `wc_ascii_decor` decorator generator object.

unspecified `unspecified

The function creates a C-style decorator generator for arbitrary character type.

` `unspecified

The function creates a C-style decorator generator for arbitrary character type.

`

Andrey Semashev

17.11.2012

The header contains implementation of a character decorator.

A simple character decorator implementation. This implementation replaces string patterns in the source string with the fixed replacements. Source patterns and replacements can be specified at the object construction.

Lengths of source pattern and replacement. unsigned int unsigned int Result type. void Character type. CharT String type. std::basic_string< char_type > result_type `string_type &``typename string_type::size_type0` Applies string replacements starting from the specified position. `RangeT const &`

Initializing constructor. Creates a pattern replacer with the specified decorations. The provided decorations must be a sequence of `std::pair` of strings. The first element of each pair is the source pattern, and the second one is the corresponding replacement.

`FromRangeT const &``ToRangeT const &`

Initializing constructor. Creates a pattern replacer with decorations specified in form of two same-sized string sequences. Each `i`'th decoration will be `from[i]` -> `to[i]`.

``pattern_replacer` const &`Copy constructor. char_type *`char_type *` const char_type *`const char_type *` range_const_iterator< RangeT >::type `RangeT const &` char_type *`char_type *` const char_type *`const char_type *` range_const_iterator< RangeT >::type `RangeT const &`

Character decorator terminal class. This formatter allows to modify strings generated by other formatters on character level. The most obvious application of decorators is replacing a certain set of characters with decorated equivalents to satisfy requirements of text-based sinks.

The ``char_decorator_terminal`` class aggregates the formatter being decorated, and a set of string pairs that are used as decorations. All decorations are applied sequentially. The ``char_decorator_terminal`` class is a formatter itself, so it can be used to construct more complex formatters, including nesting decorators.

Internal typedef for type categorization. void Implementation type. ImplT Character type. impl_type::char_type String type. impl_type::string_type Stream type. basic_formatting_ostream< char_type > Adopted actor type. SubactorT Result type definition. string_type subactor_type const &

Adopted subactor

impl_type const &

Implementation

result_type `ContextT const &`

Invokation operator

result_type `ContextT const &`

Invokation operator

`subactor_type const &``impl_type const &`

Initializing constructor.

``char_decorator_terminal` const &`

Copy constructor

template< typename > class phoenix::actor

Character decorator actor

Base terminal type. `char_decorator_terminal`< SubactorT, ImplT > Character type. terminal_type::char_type Base actor type. ActorT< terminal_type > terminal_type const &Returns reference to the terminal. `base_type const &`Initializing constructor. `unspecified `RangeT const &

A sequence of string pairs that will be used as decorations. Every `decorations[i].first` substring occurrence in the output will be replaced with `decorations[i].second`.

`

The function returns a decorator generator object. The generator provides `operator[]` that can be used to construct the actual decorator.

` `unspecified `FromRangeT const &

A sequence of strings that will be sought in the output.

``ToRangeT const &

A sequence of strings that will be used as replacements.

`

The function returns a decorator generator object. The generator provides `operator[]` that can be used to construct the actual decorator.

The from and to sequences mush be of the same size. Every `from[i]` substring occurrence in the output will be replaced with `to[i]`.

`

Andrey Semashev

18.11.2012

The header contains implementation of a CSV-style character decorator. See: http://en.wikipedia.org/wiki/Comma-separated_values unspecified

CSV-style decorator generator object. The decorator doubles double quotes that may be found in the output. See http://en.wikipedia.org/wiki/Comma-separated_values for more information on the CSV format. The generator provides `operator[]` that can be used to construct the actual decorator. For example:

`csv_decor[ stream << attr< std::string >("MyAttr") ]`

For wide-character formatting there is the similar `wcsv_decor` decorator generator object.

unspecified `unspecified

The function creates an CSV-style decorator generator for arbitrary character type.

`

Andrey Semashev

16.09.2012

The header contains a formatter function for date and time attribute values.

Date and time formatter terminal.

Internal typedef for type categorization. void Attribute value type. T Fallback policy. FallbackPolicyT Character type. CharT String type. std::basic_string< char_type > Formatting stream type. basic_formatting_ostream< char_type > Formatter function. unspecified Function result type. string_type attribute_name Returns attribute name. fallback_policy const &Returns fallback policy. formatter_function_type const &Retruns formatter function. result_type `ContextT const &`Invokation operator. result_type `ContextT const &`Invokation operator. `attribute_name const &``fallback_policy const &``string_type const &`Initializing constructor. ``format_date_time_terminal` const &`Copy constructor. template< typename > class phoenix::actor

Date and time formatter actor.

Attribute value type. T Character type. CharT Fallback policy. FallbackPolicyT Base terminal type. `format_date_time_terminal`< value_type, fallback_policy, char_type > Formatter function. terminal_type::formatter_function_type Base actor type. ActorT< terminal_type > attribute_name

The attribute name

fallback_policy const &

Fallback policy

formatter_function_type const &

Formatter function

`base_type const &`Initializing constructor. ``format_date_time_actor`< AttributeValueT, fallback_to_none, CharT > `attribute_name const &

Attribute name

``const CharT *

Format string

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_date_time_actor`< AttributeValueT, fallback_to_none, CharT > `attribute_name const &

Attribute name

``std::basic_string< CharT > const &

Format string

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_date_time_actor`< typename DescriptorT::value_type, fallback_to_none, CharT, ActorT > template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &

Attribute keyword

``const CharT *

Format string

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_date_time_actor`< typename DescriptorT::value_type, fallback_to_none, CharT, ActorT > template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &

Attribute keyword

``std::basic_string< CharT > const &

Format string

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_date_time_actor`< T, FallbackPolicyT, CharT, ActorT > template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &

Attribute placeholder

``const CharT *

Format string

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_date_time_actor`< T, FallbackPolicyT, CharT, ActorT > template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &

Attribute placeholder

``std::basic_string< CharT > const &

Format string

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

`

Andrey Semashev

15.11.2012

The header contains a generic log record formatter function. Template expressions terminal node with Boost.Format-like formatter. Internal typedef for type categorization. void Character type. CharT Boost.Format formatter type. unspecified String type. std::basic_string< char_type > Terminal result type. format_type::pump result_type `ContextT const &`Invokation operator. `const char_type *`Initializing constructor. `phoenix::actor< `format_terminal`< CharT > > `const CharT *`

The function generates a terminal node in a template expression. The node will perform log record formatting according to the provided format string.

` `phoenix::actor< `format_terminal`< CharT > > `std::basic_string< CharT, TraitsT, AllocatorT > const &`

The function generates a terminal node in a template expression. The node will perform log record formatting according to the provided format string.

`

Andrey Semashev

17.11.2012

The header contains implementation of a conditional formatter. `unspecified `CondT const &

A filter expression that will be used as the condition

`

The function returns a conditional formatter generator object. The generator provides `operator[]` that can be used to construct the actual formatter. The formatter must participate in a streaming expression.

`

Andrey Semashev

11.11.2012

The header contains a formatter function for named scope attribute values.

Named scope formatter terminal.

Internal typedef for type categorization. void Attribute value type. attributes::named_scope::value_type Fallback policy. FallbackPolicyT Character type. CharT String type. std::basic_string< char_type > Formatting stream type. basic_formatting_ostream< char_type > Formatter function. unspecified Function result type. string_type attribute_name Returns attribute name. fallback_policy const &Returns fallback policy. formatter_function_type const &Retruns formatter function. result_type `ContextT const &`Invokation operator. result_type `ContextT const &`Invokation operator. `attribute_name const &``fallback_policy const &``FormatT const &``string_type const &``string_type const &``string_type const &``value_type::size_type` `scope_iteration_direction` Initializing constructor. ``format_named_scope_terminal` const &`Copy constructor. template< typename > class phoenix::actor

Named scope formatter actor.

Character type. CharT Fallback policy. FallbackPolicyT Base terminal type. `format_named_scope_terminal`< fallback_policy, char_type > Attribute value type. terminal_type::value_type Formatter function. terminal_type::formatter_function_type Base actor type. ActorT< terminal_type > attribute_name

The attribute name

fallback_policy const &

Fallback policy

formatter_function_type const &

Formatter function

`base_type const &`Initializing constructor. Iterate through scopes from outermost to innermost. Iterate through scopes from innermost to outermost. Scope iteration directions. ``format_named_scope_actor`< fallback_to_none, CharT > `attribute_name const &

Attribute name

``const CharT *

Format string for a single named scope

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_named_scope_actor`< fallback_to_none, CharT > `attribute_name const &

Attribute name

``std::basic_string< CharT > const &

Format string for a single named scope

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_named_scope_actor`< fallback_to_none, CharT, ActorT > template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &

Attribute keyword

``const CharT *

Format string for a single named scope

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_named_scope_actor`< fallback_to_none, CharT, ActorT > template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &

Attribute keyword

``std::basic_string< CharT > const &

Format string for a single named scope

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_named_scope_actor`< FallbackPolicyT, CharT, ActorT > template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &

Attribute placeholder

``const CharT *

Format string for a single named scope

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` ``format_named_scope_actor`< FallbackPolicyT, CharT, ActorT > template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &

Attribute placeholder

``std::basic_string< CharT > const &

Format string for a single named scope

`

The function generates a manipulator node in a template expression. The manipulator must participate in a formatting expression (stream output or `format` placeholder filler).

` unspecified typename... `attribute_name const &

Attribute name

``ArgsT...const &

An set of named parameters. Supported parameters:

- `format` - A format string for named scopes. The string can contain "%n", "%f" and "%l" placeholders for the scope name, file and line number, respectively. This parameter is mandatory.

- `delimiter` - A string that is used to delimit the formatted scope names. Default: "->" or "<-", depending on the iteration direction.

- `incomplete_marker` - A string that is used to indicate that the list was printed incomplete because of depth limitation. Default: "...".

- `empty_marker` - A string that is output in case if the scope list is empty. Default: "", i.e. nothing is output.

- `iteration` - Iteration direction, see `scope_iteration_direction` enumeration. Default: forward.

- `depth` - Iteration depth. Default: unlimited.

` unspecified template< typename > class typename... ``attribute_keyword`< DescriptorT, ActorT > const &``ArgsT...const &`unspecified template< typename > class typename... ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &``ArgsT...const &`

Formatter generator. Construct the named scope formatter with the specified formatting parameters.

Andrey Semashev

24.07.2012

The header contains implementation of a stream placeholder in template expressions.

Stream placeholder type in formatter template expressions.

phoenix::expression::argument< 2 >::type const stream_type

Stream placeholder in formatter template expressions.

Andrey Semashev

24.11.2012

The header contains a formatter function wrapper that enables third-party functions to participate in formatting expressions.

Formatter function wrapper terminal.

Internal typedef for type categorization. void Character type. CharT String type. std::basic_string< char_type > Formatting stream type. basic_formatting_ostream< char_type > Wrapped function type. FunT Formatter result type. string_type function_type const &Returns the wrapped function. result_type `ContextT const &`Invokation operator. result_type `ContextT const &`Invokation operator. `function_type const &`Initializing construction. ``wrapped_formatter_terminal` const &`Copy constructor. template< typename > class phoenix::actor

Wrapped formatter function actor.

Character type. CharT Wrapped function type. FunT Base terminal type. `wrapped_formatter_terminal`< function_type, char_type > Base actor type. ActorT< terminal_type > function_type const &

The wrapped function

`base_type const &`Initializing constructor. `unspecified `FunT const &`

The function wraps a function object in order it to be able to participate in formatting expressions. The wrapped function object must be compatible with the following signature:

     void (record_view const&, basic_formatting_ostream< CharT >&)

where `CharT` is the character type of the formatting expression.

` ``wrapped_formatter_actor`< FunT, CharT > `FunT const &`

The function wraps a function object in order it to be able to participate in formatting expressions. The wrapped function object must be compatible with the following signature:

     void (record_view const&, basic_formatting_ostream< CharT >&)

where `CharT` is the character type of the formatting expression.

`

Andrey Semashev

18.11.2012

The header contains implementation of a XML-style character decorator. unspecified

XML-style decorator generator object. The decorator replaces characters that have special meaning in XML documents with the corresponding decorated counterparts. The generator provides `operator[]` that can be used to construct the actual decorator. For example:

`xml_decor[ stream << attr< std::string >("MyAttr") ]`

For wide-character formatting there is the similar `wxml_decor` decorator generator object.

unspecified `unspecified

The function creates an XML-style decorator generator for arbitrary character type.

`

Andrey Semashev

14.07.2012

The header contains attribute keyword descriptor detection trait.

Base class for keyword descriptors. All keyword descriptors must derive from this class to support the ``is_keyword_descriptor`` trait.

void

The metafunction detects if the type `T` is a keyword descriptor

Andrey Semashev

29.01.2012

The header contains attribute keyword declaration. template< typename > class

This class implements an expression template keyword. It is used to start template expressions involving attribute values.

Self type. `attribute_keyword` Attribute descriptor type. DescriptorT Attribute value type. descriptor_type::value_type Expression with cached attribute name. `attribute_actor`< value_type, fallback_to_none, descriptor_type, ActorT > Expression with cached attribute name. `attribute_actor`< value_type, fallback_to_throw, descriptor_type, ActorT > attribute_name Returns attribute name. or_none_result_type Generates an expression that extracts the attribute value or a default value. or_throw_result_type Generates an expression that extracts the attribute value or throws an exception. `attribute_actor`< value_type, fallback_to_default< DefaultT >, descriptor_type, ActorT > `DefaultT const &`Generates an expression that extracts the attribute value or a default value.

Keyword name

Attribute name string

Attribute value type

The macro declares an attribute keyword type.

The macro should be used at a namespace scope. It expands into an attribute keyword type definition, including the `tag` namespace and the keyword tag type within which has the following layout:

     namespace tag
     {
       struct keyword_ :
         public boost::log::expressions::keyword_descriptor
       {
         typedef value_type_ value_type;
         static boost::log::attribute_name get_name();
       };
     }

     typedef boost::log::expressions::attribute_keyword< tag::keyword_ > keyword_type;

The `get_name` method returns the attribute name.

This macro only defines the type of the keyword. To also define the keyword object, use the `BOOST_LOG_ATTRIBUTE_KEYWORD` macro instead.

Keyword name

Attribute name string

Attribute value type

The macro declares an attribute keyword.

The macro provides definitions similar to `BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE` and additionally defines the keyword object.

Andrey Semashev

29.01.2012

The header contains attribute keyword forward declaration.

Andrey Semashev

13.07.2012

The header contains log message keyword declaration. keyword_descriptor

Generic log message attribute descriptor.

void mpl::vector2< std::string, std::wstring > attribute_name keyword_descriptor

Narrow character log message attribute descriptor.

void std::string attribute_name keyword_descriptor

Wide character log message attribute descriptor.

void std::wstring attribute_name

Generic message keyword type.

`attribute_keyword`< `tag::message` >

Narrow message keyword type.

`attribute_keyword`< `tag::smessage` >

Wide message keyword type.

`attribute_keyword`< `tag::wmessage` > const `message_type`

Generic message keyword.

const `smessage_type`

Narrow message keyword.

const `wmessage_type`

Wide message keyword.

Andrey Semashev

29.01.2012

The header includes all template expression predicates.

Andrey Semashev

02.09.2012

The header contains implementation of a `begins_with` predicate in template expressions. `unspecified template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, begins with the specified substring.

` `unspecified template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, begins with the specified substring.

` `unspecified `attribute_name const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, begins with the specified substring.

`

Andrey Semashev

25.11.2012

The header contains implementation of a minimal severity per channel filter. fallback_to_none fallback_to_none less greater_equal std::allocator< void > Channel visitor. void result_type `channel_value_type const &` `channel_severity_filter_terminal const &``ArgT` `bool &` Severity level visitor. void result_type `severity_value_type const &` `channel_severity_filter_terminal const &``severity_value_type const &``bool &` Internal typedef for type categorization. void Function result type. bool Channel attribute value type. ChannelT Channel fallback policy. ChannelFallbackT Severity level attribute value type. SeverityT Severity level fallback policy. SeverityFallbackT void `channel_value_type const &``severity_value_type const &`Adds a new element to the mapping. void `bool` Sets the default result of the predicate. result_type `ContextT const &`Invokation operator. `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()`Initializing constructor. void `channel_value_type const &``ArgT const &``bool &`Visits channel name. void `severity_value_type const &``severity_value_type const &``bool &`Visits severity level. fallback_to_none fallback_to_none less greater_equal std::allocator< void > template< typename > class phoenix::actor An auxiliary pseudo-reference to implement insertion through subscript operator. `channel_severity_filter_actor &``channel_value_type const &` void `severity_value_type const &` Terminal type. channel_severity_filter_terminal< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, ChannelOrderT, SeverityCompareT, AllocatorT > Base actor type. ActorT< terminal_type > Channel attribute value type. terminal_type::channel_value_type Channel fallback policy. terminal_type::channel_fallback_policy Severity level attribute value type. terminal_type::severity_value_type Severity level fallback policy. terminal_type::severity_fallback_policy this_type &`bool` Sets the default function result. this_type &`channel_value_type const &``severity_value_type const &`Adds a new element to the mapping. subscript_result `channel_value_type const &`Alternative interface for adding a new element to the mapping. `base_type const &`Initializing constructor. `channel_severity_filter_actor const &`Copy constructor. channel_severity_filter_actor< ChannelT, SeverityT > `attribute_name const &``attribute_name const &`channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &``attribute_name const &`channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT > template< typename > class `attribute_name const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &`channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &`channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &``attribute_name const &`channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, greater_equal, std::allocator< void >, ActorT > template< typename > class `attribute_name const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &`channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, greater_equal, std::allocator< void >, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &`channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT > `attribute_name const &``attribute_name const &``SeverityCompareT const &`channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &``attribute_name const &``SeverityCompareT const &`channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class `attribute_name const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &`channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &`channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &``attribute_name const &``SeverityCompareT const &`channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class `attribute_name const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &`channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &`channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT > `attribute_name const &``attribute_name const &``SeverityCompareT const &``ChannelOrderT const &`channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &``attribute_name const &``SeverityCompareT const &``ChannelOrderT const &`channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class `attribute_name const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &``attribute_name const &``SeverityCompareT const &``ChannelOrderT const &`channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class `attribute_name const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`

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.

Andrey Semashev

02.09.2012

The header contains implementation of a `contains` predicate in template expressions. `unspecified template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, contains the specified substring.

` `unspecified template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, contains the specified substring.

` `unspecified `attribute_name const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, contains the specified substring.

`

Andrey Semashev

02.09.2012

The header contains implementation of a `ends_with` predicate in template expressions. `unspecified template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, ends with the specified substring.

` `unspecified template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, ends with the specified substring.

` `unspecified `attribute_name const &``SubstringT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, ends with the specified substring.

`

Andrey Semashev

23.07.2012

The header contains implementation of a generic attribute presence checker in template expressions.

An attribute value presence checker.

Function result_type. bool Expected attribute value type. T result_type `ArgT const &

A set of attribute values or a log record

`

Checking operator

`true` if the log record contains the sought attribute value, `false` otherwise

`attribute_name const &

Attribute name

`

Initializing constructor

void

An attribute value presence checker. This specialization does not check the type of the attribute value.

Function result_type. bool Expected attribute value type. void result_type `attribute_value_set const &

A set of attribute values

`

Checking operator

`true` if the log record contains the sought attribute value, `false` otherwise

result_type `boost::log::record_view const &

A log record

`

Checking operator

`true` if the log record contains the sought attribute value, `false` otherwise

`attribute_name const &

Attribute name

`

Initializing constructor

`unspecified `attribute_name const &`

The function generates a terminal node in a template expression. The node will check for the attribute value presence in a log record. The node will also check that the attribute value has the specified type, if present.

The function generates a terminal node in a template expression. The node will check for the attribute value presence in a log record.

` `unspecified template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &`

The function generates a terminal node in a template expression. The node will check for the attribute value presence in a log record. The node will also check that the attribute value has the specified type, if present.

`

Andrey Semashev

05.12.2012

The header contains implementation of the `is_debugger_present` predicate in template expressions.

Andrey Semashev

02.09.2012

The header contains implementation of an `is_in_range` predicate in template expressions. `unspecified template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &``BoundaryT const &``BoundaryT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value is in the specified range. The range must be half-open, that is the predicate will be equivalent to `least <= attr < most`.

` `unspecified template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &``BoundaryT const &``BoundaryT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value is in the specified range. The range must be half-open, that is the predicate will be equivalent to `least <= attr < most`.

` `unspecified `attribute_name const &``BoundaryT const &``BoundaryT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value is in the specified range. The range must be half-open, that is the predicate will be equivalent to `least <= attr < most`.

`

Andrey Semashev

02.09.2012

The header contains implementation of a `matches` predicate in template expressions. fallback_to_none

The predicate checks if the attribute value matches a regular expression. The attribute value is assumed to be of a string type.

`attribute_name const &

Attribute name

``RegexT const &

The regular expression to match the attribute value against

`

Initializing constructor

`attribute_name const &

Attribute name

``RegexT const &

The regular expression to match the attribute value against

``U const &

Additional parameter for the fallback policy

`

Initializing constructor

`unspecified template< typename > class ``attribute_actor`< T, FallbackPolicyT, TagT, ActorT > const &``RegexT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, matches the specified regular expression.

` `unspecified template< typename > class ``attribute_keyword`< DescriptorT, ActorT > const &``RegexT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, matches the specified regular expression.

` `unspecified `attribute_name const &``RegexT const &`

The function generates a terminal node in a template expression. The node will check if the attribute value, which is assumed to be a string, matches the specified regular expression.

`

Andrey Semashev

25.07.2012

The header contains implementation of a log record placeholder in template expressions.

Log record placeholder type in formatter template expressions.

phoenix::expression::argument< 1 >::type const record_type

Log record placeholder in formatter template expressions.