### Expressions

#### Header <boost/log/expressions/attr.hpp>

Andrey Semashev

21.07.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename AttributeValueT>
            attribute_actor< AttributeValueT > attr(attribute_name const &);
          template<typename AttributeValueT, typename TagT>
            attribute_actor< AttributeValueT, fallback_to_none, TagT >
            attr(attribute_name const &);
        }
      }
    }

#### Header <boost/log/expressions/attr_fwd.hpp>

Andrey Semashev

21.07.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT>
            class attribute_actor;
          template<typename T, typename FallbackPolicyT, typename TagT>
            class attribute_terminal;
        }
      }
    }

#### Header <boost/log/expressions/filter.hpp>

Andrey Semashev

13.07.2012

The header contains a filter function object definition.

    namespace boost {
      namespace log {
        class filter;
        void swap(filter &, filter &);
      }
    }

#### Header <boost/log/expressions/formatter.hpp>

Andrey Semashev

13.07.2012

The header contains a formatter function object definition.

    namespace boost {
      namespace log {
        template<typename CharT> class basic_formatter;

        typedef basic_formatter< char > formatter;
        typedef basic_formatter< wchar_t > wformatter;
        template<typename CharT>
          void swap(basic_formatter< CharT > &, basic_formatter< CharT > &);
        namespace expressions {
        }
      }
    }

#### Header <boost/log/expressions/formatters.hpp>

Andrey Semashev

10.11.2012

The header includes all template expression formatters.

#### Header <boost/log/expressions/formatters/c_decorator.hpp>

Andrey Semashev

18.11.2012

The header contains implementation of C-style character decorators.

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename CharT> class c_ascii_pattern_replacer;

          unspecified c_decor;
          unspecified wc_decor;
          unspecified c_ascii_decor;
          unspecified wc_ascii_decor;
          template<typename CharT> unspecified make_c_decor();
          template<typename CharT> unspecified make_c_ascii_decor();
        }
      }
    }

#### Header <boost/log/expressions/formatters/char_decorator.hpp>

Andrey Semashev

17.11.2012

The header contains implementation of a character decorator.

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename SubactorT, typename ImplT,
                   template< typename > class ActorT = phoenix::actor>
            class char_decorator_actor;
          template<typename SubactorT, typename ImplT> class char_decorator_terminal;
          template<typename CharT> class pattern_replacer;
          template<typename RangeT> unspecified char_decor(RangeT const &);
          template<typename FromRangeT, typename ToRangeT>
            unspecified char_decor(FromRangeT const &, ToRangeT const &);
        }
      }
    }

#### Header <boost/log/expressions/formatters/csv_decorator.hpp>

Andrey Semashev

18.11.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          unspecified csv_decor;
          unspecified wcsv_decor;
          template<typename CharT> unspecified make_csv_decor();
        }
      }
    }

#### Header <boost/log/expressions/formatters/date_time.hpp>

Andrey Semashev

16.09.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename T, typename FallbackPolicyT, typename CharT,
                   template< typename > class ActorT = phoenix::actor>
            class format_date_time_actor;
          template<typename T, typename FallbackPolicyT, typename CharT>
            class format_date_time_terminal;
          template<typename AttributeValueT, typename CharT>
            format_date_time_actor< AttributeValueT, fallback_to_none, CharT >
            format_date_time(attribute_name const &, const CharT *);
          template<typename AttributeValueT, typename CharT>
            format_date_time_actor< AttributeValueT, fallback_to_none, CharT >
            format_date_time(attribute_name const &,
                             std::basic_string< CharT > const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename CharT>
            format_date_time_actor< typename DescriptorT::value_type, fallback_to_none, CharT, ActorT >
            format_date_time(attribute_keyword< DescriptorT, ActorT > const &,
                             const CharT *);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename CharT>
            format_date_time_actor< typename DescriptorT::value_type, fallback_to_none, CharT, ActorT >
            format_date_time(attribute_keyword< DescriptorT, ActorT > const &,
                             std::basic_string< CharT > const &);
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename CharT>
            format_date_time_actor< T, FallbackPolicyT, CharT, ActorT >
            format_date_time(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                             const CharT *);
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename CharT>
            format_date_time_actor< T, FallbackPolicyT, CharT, ActorT >
            format_date_time(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                             std::basic_string< CharT > const &);
        }
      }
    }

#### Header <boost/log/expressions/formatters/format.hpp>

Andrey Semashev

15.11.2012

The header contains a generic log record formatter function.

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename CharT> class format_terminal;
          template<typename CharT>
            phoenix::actor< format_terminal< CharT > > format(const CharT *);
          template<typename CharT, typename TraitsT, typename AllocatorT>
            phoenix::actor< format_terminal< CharT > >
            format(std::basic_string< CharT, TraitsT, AllocatorT > const &);
        }
      }
    }

#### Header <boost/log/expressions/formatters/if.hpp>

Andrey Semashev

17.11.2012

The header contains implementation of a conditional formatter.

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename CondT> unspecified if_(CondT const &);
        }
      }
    }

#### Header <boost/log/expressions/formatters/named_scope.hpp>

Andrey Semashev

11.11.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename FallbackPolicyT, typename CharT,
                   template< typename > class ActorT = phoenix::actor>
            class format_named_scope_actor;
          template<typename FallbackPolicyT, typename CharT>
            class format_named_scope_terminal;

          // Scope iteration directions.
          enum scope_iteration_direction { forward, reverse };
          template<typename CharT>
            format_named_scope_actor< fallback_to_none, CharT >
            format_named_scope(attribute_name const &, const CharT *);
          template<typename CharT>
            format_named_scope_actor< fallback_to_none, CharT >
            format_named_scope(attribute_name const &,
                               std::basic_string< CharT > const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename CharT>
            format_named_scope_actor< fallback_to_none, CharT, ActorT >
            format_named_scope(attribute_keyword< DescriptorT, ActorT > const &,
                               const CharT *);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename CharT>
            format_named_scope_actor< fallback_to_none, CharT, ActorT >
            format_named_scope(attribute_keyword< DescriptorT, ActorT > const &,
                               std::basic_string< CharT > const &);
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename CharT>
            format_named_scope_actor< FallbackPolicyT, CharT, ActorT >
            format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                               const CharT *);
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename CharT>
            format_named_scope_actor< FallbackPolicyT, CharT, ActorT >
            format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                               std::basic_string< CharT > const &);
          template<typename... ArgsT>
            unspecified format_named_scope(attribute_name const &,
                                           ArgsT...const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename... ArgsT>
            unspecified format_named_scope(attribute_keyword< DescriptorT, ActorT > const &,
                                           ArgsT...const &);
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename... ArgsT>
            unspecified format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                                           ArgsT...const &);
        }
      }
    }

#### Header <boost/log/expressions/formatters/stream.hpp>

Andrey Semashev

24.07.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          typedef phoenix::expression::argument< 2 >::type stream_type;

          const stream_type stream;
        }
      }
    }

#### Header <boost/log/expressions/formatters/wrap_formatter.hpp>

Andrey Semashev

24.11.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename FunT, typename CharT,
                   template< typename > class ActorT = phoenix::actor>
            class wrapped_formatter_actor;
          template<typename FunT, typename CharT> class wrapped_formatter_terminal;
          template<typename FunT> unspecified wrap_formatter(FunT const &);
          template<typename CharT, typename FunT>
            wrapped_formatter_actor< FunT, CharT > wrap_formatter(FunT const &);
        }
      }
    }

#### Header <boost/log/expressions/formatters/xml_decorator.hpp>

Andrey Semashev

18.11.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          unspecified xml_decor;
          unspecified wxml_decor;
          template<typename CharT> unspecified make_xml_decor();
        }
      }
    }

#### Header <boost/log/expressions/is_keyword_descriptor.hpp>

Andrey Semashev

14.07.2012

The header contains attribute keyword descriptor detection trait.

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename T, typename VoidT = void> struct is_keyword_descriptor;
          struct keyword_descriptor;
        }
      }
    }

#### Header <boost/log/expressions/keyword.hpp>

Andrey Semashev

29.01.2012

The header contains attribute keyword declaration.

    BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE(keyword_, name_, value_type_)
    BOOST_LOG_ATTRIBUTE_KEYWORD(keyword_, name_, value_type_)

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename DescriptorT, template< typename > class ActorT>
            struct attribute_keyword;
        }
      }
    }

#### Header <boost/log/expressions/keyword_fwd.hpp>

Andrey Semashev

29.01.2012

The header contains attribute keyword forward declaration.

#### Header <boost/log/expressions/message.hpp>

Andrey Semashev

13.07.2012

The header contains log message keyword declaration.

    namespace boost {
      namespace log {
        namespace expressions {
          typedef attribute_keyword< tag::message > message_type;
          typedef attribute_keyword< tag::smessage > smessage_type;
          typedef attribute_keyword< tag::wmessage > wmessage_type;

          const message_type message;
          const smessage_type smessage;
          const wmessage_type wmessage;
          namespace tag {
            struct message;
            struct smessage;
            struct wmessage;
          }
        }
      }
    }

#### Header <boost/log/expressions/predicates.hpp>

Andrey Semashev

29.01.2012

The header includes all template expression predicates.

#### Header <boost/log/expressions/predicates/begins_with.hpp>

Andrey Semashev

02.09.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          typedef unspecified attribute_begins_with;
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename SubstringT>
            unspecified begins_with(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                                    SubstringT const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename SubstringT>
            unspecified begins_with(attribute_keyword< DescriptorT, ActorT > const &,
                                    SubstringT const &);
          template<typename T, typename SubstringT>
            unspecified begins_with(attribute_name const &, SubstringT const &);
        }
      }
    }

#### Header <boost/log/expressions/predicates/channel_severity_filter.hpp>

Andrey Semashev

25.11.2012

The header contains implementation of a minimal severity per channel filter.

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename ChannelT, typename SeverityT,
                   typename ChannelFallbackT = fallback_to_none,
                   typename SeverityFallbackT = fallback_to_none,
                   typename ChannelOrderT = less,
                   typename SeverityCompareT = greater_equal,
                   typename AllocatorT = std::allocator< void >,
                   template< typename > class ActorT = phoenix::actor>
            class channel_severity_filter_actor;
          template<typename ChannelT, typename SeverityT,
                   typename ChannelFallbackT = fallback_to_none,
                   typename SeverityFallbackT = fallback_to_none,
                   typename ChannelOrderT = less,
                   typename SeverityCompareT = greater_equal,
                   typename AllocatorT = std::allocator< void > >
            class channel_severity_filter_terminal;
          template<typename ChannelT, typename SeverityT>
            channel_severity_filter_actor< ChannelT, SeverityT >
            channel_severity_filter(attribute_name const &,
                                    attribute_name const &);
          template<typename SeverityT, typename ChannelDescriptorT,
                   template< typename > class ActorT>
            channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const &,
                                    attribute_name const &);
          template<typename ChannelT, typename SeverityDescriptorT,
                   template< typename > class ActorT>
            channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_name const &,
                                    attribute_keyword< SeverityDescriptorT, ActorT > const &);
          template<typename ChannelDescriptorT, typename SeverityDescriptorT,
                   template< typename > class ActorT>
            channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const &,
                                    attribute_keyword< SeverityDescriptorT, ActorT > const &);
          template<typename SeverityT, typename ChannelT,
                   typename ChannelFallbackT, typename ChannelTagT,
                   template< typename > class ActorT>
            channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, greater_equal, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &,
                                    attribute_name const &);
          template<typename ChannelT, typename SeverityT,
                   typename SeverityFallbackT, typename SeverityTagT,
                   template< typename > class ActorT>
            channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, greater_equal, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_name const &,
                                    attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &);
          template<typename ChannelT, typename ChannelFallbackT,
                   typename ChannelTagT, typename SeverityT,
                   typename SeverityFallbackT, typename SeverityTagT,
                   template< typename > class ActorT>
            channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, greater_equal, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &,
                                    attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &);
          template<typename ChannelT, typename SeverityT,
                   typename SeverityCompareT>
            channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT >
            channel_severity_filter(attribute_name const &,
                                    attribute_name const &,
                                    SeverityCompareT const &);
          template<typename SeverityT, typename ChannelDescriptorT,
                   template< typename > class ActorT, typename SeverityCompareT>
            channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const &,
                                    attribute_name const &,
                                    SeverityCompareT const &);
          template<typename ChannelT, typename SeverityDescriptorT,
                   template< typename > class ActorT, typename SeverityCompareT>
            channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_name const &,
                                    attribute_keyword< SeverityDescriptorT, ActorT > const &,
                                    SeverityCompareT const &);
          template<typename ChannelDescriptorT, typename SeverityDescriptorT,
                   template< typename > class ActorT, typename SeverityCompareT>
            channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const &,
                                    attribute_keyword< SeverityDescriptorT, ActorT > const &,
                                    SeverityCompareT const &);
          template<typename SeverityT, typename ChannelT,
                   typename ChannelFallbackT, typename ChannelTagT,
                   template< typename > class ActorT, typename SeverityCompareT>
            channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, less, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &,
                                    attribute_name const &,
                                    SeverityCompareT const &);
          template<typename ChannelT, typename SeverityT,
                   typename SeverityFallbackT, typename SeverityTagT,
                   template< typename > class ActorT, typename SeverityCompareT>
            channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, less, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_name const &,
                                    attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &,
                                    SeverityCompareT const &);
          template<typename ChannelT, typename ChannelFallbackT,
                   typename ChannelTagT, typename SeverityT,
                   typename SeverityFallbackT, typename SeverityTagT,
                   template< typename > class ActorT, typename SeverityCompareT>
            channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, less, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &,
                                    attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &,
                                    SeverityCompareT const &);
          template<typename ChannelT, typename SeverityT,
                   typename SeverityCompareT, typename ChannelOrderT>
            channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT >
            channel_severity_filter(attribute_name const &,
                                    attribute_name const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
          template<typename SeverityT, typename ChannelDescriptorT,
                   template< typename > class ActorT, typename SeverityCompareT,
                   typename ChannelOrderT>
            channel_severity_filter_actor< typename ChannelDescriptorT::value_type, SeverityT, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const &,
                                    attribute_name const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
          template<typename ChannelT, typename SeverityDescriptorT,
                   template< typename > class ActorT, typename SeverityCompareT,
                   typename ChannelOrderT>
            channel_severity_filter_actor< ChannelT, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_name const &,
                                    attribute_keyword< SeverityDescriptorT, ActorT > const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
          template<typename ChannelDescriptorT, typename SeverityDescriptorT,
                   template< typename > class ActorT, typename SeverityCompareT,
                   typename ChannelOrderT>
            channel_severity_filter_actor< typename ChannelDescriptorT::value_type, typename SeverityDescriptorT::value_type, fallback_to_none, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_keyword< ChannelDescriptorT, ActorT > const &,
                                    attribute_keyword< SeverityDescriptorT, ActorT > const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
          template<typename SeverityT, typename ChannelT,
                   typename ChannelFallbackT, typename ChannelTagT,
                   template< typename > class ActorT, typename SeverityCompareT,
                   typename ChannelOrderT>
            channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, fallback_to_none, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &,
                                    attribute_name const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
          template<typename ChannelT, typename SeverityT,
                   typename SeverityFallbackT, typename SeverityTagT,
                   template< typename > class ActorT, typename SeverityCompareT,
                   typename ChannelOrderT>
            channel_severity_filter_actor< ChannelT, SeverityT, fallback_to_none, SeverityFallbackT, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_name const &,
                                    attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
          template<typename ChannelT, typename ChannelFallbackT,
                   typename ChannelTagT, typename SeverityT,
                   typename SeverityFallbackT, typename SeverityTagT,
                   template< typename > class ActorT, typename SeverityCompareT,
                   typename ChannelOrderT>
            channel_severity_filter_actor< ChannelT, SeverityT, ChannelFallbackT, SeverityFallbackT, ChannelOrderT, SeverityCompareT, std::allocator< void >, ActorT >
            channel_severity_filter(attribute_actor< ChannelT, ChannelFallbackT, ChannelTagT, ActorT > const &,
                                    attribute_actor< SeverityT, SeverityFallbackT, SeverityTagT, ActorT > const &,
                                    SeverityCompareT const &,
                                    ChannelOrderT const &);
        }
      }
    }

#### Header <boost/log/expressions/predicates/contains.hpp>

Andrey Semashev

02.09.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          typedef unspecified attribute_contains;
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename SubstringT>
            unspecified contains(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                                 SubstringT const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename SubstringT>
            unspecified contains(attribute_keyword< DescriptorT, ActorT > const &,
                                 SubstringT const &);
          template<typename T, typename SubstringT>
            unspecified contains(attribute_name const &, SubstringT const &);
        }
      }
    }

#### Header <boost/log/expressions/predicates/ends_with.hpp>

Andrey Semashev

02.09.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          typedef unspecified attribute_ends_with;
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename SubstringT>
            unspecified ends_with(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                                  SubstringT const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename SubstringT>
            unspecified ends_with(attribute_keyword< DescriptorT, ActorT > const &,
                                  SubstringT const &);
          template<typename T, typename SubstringT>
            unspecified ends_with(attribute_name const &, SubstringT const &);
        }
      }
    }

#### Header <boost/log/expressions/predicates/has_attr.hpp>

Andrey Semashev

23.07.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename T> class has_attribute;

          template<> class has_attribute<void>;
          template<typename AttributeValueT>
            unspecified has_attr(attribute_name const &);
          template<typename DescriptorT, template< typename > class ActorT>
            unspecified has_attr(attribute_keyword< DescriptorT, ActorT > const &);
        }
      }
    }

#### Header <boost/log/expressions/predicates/is_debugger_present.hpp>

Andrey Semashev

05.12.2012

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

#### Header <boost/log/expressions/predicates/is_in_range.hpp>

Andrey Semashev

02.09.2012

The header contains implementation of an `is_in_range` predicate in template expressions.

    namespace boost {
      namespace log {
        namespace expressions {
          typedef unspecified attribute_is_in_range;
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename BoundaryT>
            unspecified is_in_range(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                                    BoundaryT const &, BoundaryT const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename BoundaryT>
            unspecified is_in_range(attribute_keyword< DescriptorT, ActorT > const &,
                                    BoundaryT const &, BoundaryT const &);
          template<typename T, typename BoundaryT>
            unspecified is_in_range(attribute_name const &, BoundaryT const &,
                                    BoundaryT const &);
        }
      }
    }

#### Header <boost/log/expressions/predicates/matches.hpp>

Andrey Semashev

02.09.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          template<typename T, typename RegexT,
                   typename FallbackPolicyT = fallback_to_none>
            class attribute_matches;
          template<typename T, typename FallbackPolicyT, typename TagT,
                   template< typename > class ActorT, typename RegexT>
            unspecified matches(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const &,
                                RegexT const &);
          template<typename DescriptorT, template< typename > class ActorT,
                   typename RegexT>
            unspecified matches(attribute_keyword< DescriptorT, ActorT > const &,
                                RegexT const &);
          template<typename T, typename RegexT>
            unspecified matches(attribute_name const &, RegexT const &);
        }
      }
    }

#### Header <boost/log/expressions/record.hpp>

Andrey Semashev

25.07.2012

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

    namespace boost {
      namespace log {
        namespace expressions {
          typedef phoenix::expression::argument< 1 >::type record_type;

          const record_type record;
        }
      }
    }