# Expressions

Andrey Semashev

21.07.2012

The header contains implementation of a generic attribute placeholder in template expressions. ``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. template< typename > class ActorT< attribute_terminal< T, FallbackPolicyT, TagT > >

An attribute value extraction terminal actor

`base_type const &`Initializing constructor. 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.

An attribute value extraction terminal

`attribute_name const &`

Initializing constructor

`attribute_name const &``U const &`

Initializing constructor

attribute_name

Attribute value name

fallback_policy const &

Fallback policy

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

The operator extracts attribute value

`result`< constthis_type(ContextTconst &)>::type `ContextT const &`

The operator extracts attribute value

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

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.

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

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

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.

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

`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

23.06.2019

The header contains implementation of formatter for inserting a newline, unless there is already one inserted.

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 Default constructor. result_type `string_type &``typename string_type::size_type0` Applies string replacements starting from the specified position. 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. template< typename > class phoenix::actor phoenix::actor< char_decorator_terminal< SubactorT, ImplT > >

Character decorator actor

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

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.

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 &``impl_type const &`

Initializing constructor.

``char_decorator_terminal` const &`

Copy constructor

subactor_type const &

Adopted subactor

impl_type const &

Implementation

result_type `ContextT const &`

Invokation operator

result_type `ContextT const &`

Invokation operator

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 > `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. result_type `string_type &``typename string_type::size_type0` Applies string replacements starting from the specified position. 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 &` `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. template< typename > class phoenix::actor phoenix::actor< format_date_time_terminal< T, FallbackPolicyT, CharT > >

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 > `base_type const &`Initializing constructor. attribute_name

The attribute name

fallback_policy const &

Fallback policy

formatter_function_type const &

Formatter function

Date and time formatter terminal.

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 const &``fallback_policy const &``string_type const &`Initializing constructor. ``format_date_time_terminal` const &`Copy constructor. 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. ``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. Character type. CharT Boost.Format formatter type. unspecified String type. std::basic_string< char_type > Terminal result type. format_type::pump `const char_type *`Initializing constructor. result_type `ContextT const &`Invokation operator. `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

06.07.2016

The header contains implementation of a string length limiting decorator. template< typename > class phoenix::actor phoenix::actor< max_size_decorator_terminal< SubactorT, CharT > >

Character decorator actor

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

String size limiting decorator terminal class. This formatter allows to limit the maximum total length of the strings generated by other formatters.

The `max_size_decorator_terminal` class aggregates the formatter being decorated, the maximum string length it can produce and an optional truncation marker string, which will be put at the end of the output if the limit is exceeded. Note that the marker length is included in the limit and as such must not exceed it. The `max_size_decorator_terminal` class is a formatter itself, so it can be used to construct more complex formatters, including nesting decorators.

Character type. CharT String type. std::basic_string< char_type > String size type. std::size_t Stream type. basic_formatting_ostream< char_type > Adopted actor type. SubactorT Result type definition. string_type `subactor_type const &``size_type` `string_type const &string_type()`

Initializing constructor.

``max_size_decorator_terminal` const &`

Copy constructor

subactor_type const &

Adopted subactor

size_type

Max string size limit

string_type const &

Max string size limit

result_type `ContextT const &`

Invokation operator

result_type `ContextT const &`

Invokation operator

`unspecified `std::size_t

The maximum number of characters (i.e. string element objects) that the decorated formatter can produce.

`

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

` `unspecified `std::size_t

The maximum number of characters (i.e. string element objects) that the decorated formatter can produce.

``const CharT *

The marker string which is appended to the output if the max_size limit is exceeded. Must be a non-null pointer to a zero-terminated string.

`

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

The overflow_marker length must not exceed the max_size limit.

` `unspecified `std::size_t

The maximum number of characters (i.e. string element objects) that the decorated formatter can produce.

``std::basic_string< CharT > const &

The marker string which is appended to the output if the max_size limit is exceeded.

`

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

The overflow_marker length must not exceed the max_size limit.

`

Andrey Semashev

11.11.2012

The header contains a formatter function for named scope attribute values. template< typename > class phoenix::actor phoenix::actor< format_named_scope_terminal< FallbackPolicyT, CharT > >

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 > `base_type const &`Initializing constructor. attribute_name

The attribute name

fallback_policy const &

Fallback policy

formatter_function_type const &

Formatter function

Named scope formatter terminal.

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 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. 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. 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. template< typename > class phoenix::actor phoenix::actor< wrapped_formatter_terminal< FunT, CharT > >

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 > `base_type const &`Initializing constructor. function_type const &

The wrapped function

Formatter function wrapper terminal.

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 &`Initializing construction. ``wrapped_formatter_terminal` const &`Copy constructor. function_type const &Returns the wrapped function. result_type `ContextT const &`Invokation operator. result_type `ContextT const &`Invokation operator. `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 >&) const

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

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. void false_

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

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

Andrey Semashev

29.01.2012

The header contains attribute keyword declaration.

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. template< typename > class This class implements an expression template keyword.

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

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.

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.

The predicate checks if the attribute value begins with a substring. The attribute value is assumed to be of a string type.

unspecified `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 use_std_allocator template< typename > class phoenix::actor phoenix::actor< channel_severity_filter_terminal< ChannelT, SeverityT, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator > >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 `base_type const &`Initializing constructor. `channel_severity_filter_actor const &`Copy constructor. 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. fallback_to_none fallback_to_none less greater_equal use_std_allocator Channel visitor. void `channel_severity_filter_terminal const &``ArgT` `bool &` result_type `channel_value_type const &` Severity level visitor. void `channel_severity_filter_terminal const &``severity_value_type const &``bool &` result_type `severity_value_type const &` Function result type. bool Channel attribute value type. ChannelT Channel fallback policy. ChannelFallbackT Severity level attribute value type. SeverityT Severity level fallback policy. SeverityFallbackT `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 &``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. void `channel_value_type const &``ArgT const &``bool &`Visits channel name. void `severity_value_type const &``severity_value_type const &``bool &`Visits severity level. `channel_severity_filter_actor< ChannelT, SeverityT > `attribute_name const &``attribute_name 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.

` `channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &``attribute_name const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > template< typename > class `attribute_name const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `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 > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, greater_equal, use_std_allocator, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &``attribute_name const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, greater_equal, use_std_allocator, ActorT > template< typename > class `attribute_name const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, greater_equal, use_std_allocator, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT > `attribute_name const &``attribute_name const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &``attribute_name const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > template< typename > class `attribute_name const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &``attribute_name const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, SeverityCompareT, use_std_allocator, ActorT > template< typename > class `attribute_name const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT > `attribute_name const &``attribute_name const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &``attribute_name const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > template< typename > class `attribute_name const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_keyword`< ChannelDescriptorT, ActorT > const &```attribute_keyword`< SeverityDescriptorT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &``attribute_name const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > template< typename > class `attribute_name const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.` `channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, ChannelOrderT, SeverityCompareT, use_std_allocator, ActorT > template< typename > class ``attribute_actor`< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &```attribute_actor`< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &``SeverityCompareT const &``ChannelOrderT const &`This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.`

Andrey Semashev

02.09.2012

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

The predicate checks if the attribute value contains a substring. The attribute value is assumed to be of a string type.

unspecified `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.

The predicate checks if the attribute value ends with a substring. The attribute value is assumed to be of a string type.

unspecified `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 `attribute_name const &

Attribute name

`

Initializing constructor

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

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 `attribute_name const &

Attribute name

`

Initializing constructor

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

`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.

` `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.

` `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.

The predicate checks if the attribute value contains a substring. The attribute value is assumed to be of a string type.

unspecified `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

09.07.2025

The header contains a filter function wrapper that enables third-party functions to participate in filtering expressions. `unspecified `FunT &&`

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

    bool (attribute_value_set const& values) const

The wrapped function must return `true` if the log record is to be passed by the filter and `false` otherwise.

`

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.