Boost C++ Libraries

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

PrevUpHomeNext

Expressions

Header <boost/log/expressions/attr.hpp>
Header <boost/log/expressions/attr_fwd.hpp>
Header <boost/log/expressions/filter.hpp>
Header <boost/log/expressions/formatter.hpp>
Header <boost/log/expressions/formatters.hpp>
Header <boost/log/expressions/formatters/c_decorator.hpp>
Header <boost/log/expressions/formatters/char_decorator.hpp>
Header <boost/log/expressions/formatters/csv_decorator.hpp>
Header <boost/log/expressions/formatters/date_time.hpp>
Header <boost/log/expressions/formatters/format.hpp>
Header <boost/log/expressions/formatters/if.hpp>
Header <boost/log/expressions/formatters/max_size_decorator.hpp>
Header <boost/log/expressions/formatters/named_scope.hpp>
Header <boost/log/expressions/formatters/stream.hpp>
Header <boost/log/expressions/formatters/wrap_formatter.hpp>
Header <boost/log/expressions/formatters/xml_decorator.hpp>
Header <boost/log/expressions/is_keyword_descriptor.hpp>
Header <boost/log/expressions/keyword.hpp>
Header <boost/log/expressions/keyword_fwd.hpp>
Header <boost/log/expressions/message.hpp>
Header <boost/log/expressions/predicates.hpp>
Header <boost/log/expressions/predicates/begins_with.hpp>
Header <boost/log/expressions/predicates/channel_severity_filter.hpp>
Header <boost/log/expressions/predicates/contains.hpp>
Header <boost/log/expressions/predicates/ends_with.hpp>
Header <boost/log/expressions/predicates/has_attr.hpp>
Header <boost/log/expressions/predicates/is_debugger_present.hpp>
Header <boost/log/expressions/predicates/is_in_range.hpp>
Header <boost/log/expressions/predicates/matches.hpp>
Header <boost/log/expressions/record.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 &);
    }
  }
}

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 = fallback_to_none, 
               typename TagT = void> 
        class attribute_terminal;
      template<typename T, typename FallbackPolicyT = fallback_to_none, 
               typename TagT = void, 
               template< typename > class ActorT = phoenix::actor> 
        class attribute_actor;
    }
  }
}

Andrey Semashev

13.07.2012

The header contains a filter function object definition.

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

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 {
    }
  }
}

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.

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();
    }
  }
}

Andrey Semashev

17.11.2012

The header contains implementation of a character decorator.

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

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();
    }
  }
}

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> 
        class format_date_time_terminal;
      template<typename T, typename FallbackPolicyT, typename CharT, 
               template< typename > class ActorT = phoenix::actor> 
        class format_date_time_actor;
      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 &);
    }
  }
}

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 &);
    }
  }
}

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 &);
    }
  }
}

Andrey Semashev

06.07.2016

The header contains implementation of a string length limiting decorator.

namespace boost {
  namespace log {
    namespace expressions {
      template<typename SubactorT, typename CharT> 
        class max_size_decorator_terminal;
      template<typename SubactorT, typename CharT, 
               template< typename > class ActorT = phoenix::actor> 
        class max_size_decorator_actor;
      template<typename CharT> unspecified max_size_decor(std::size_t);
      template<typename CharT> 
        unspecified max_size_decor(std::size_t, const CharT *);
      template<typename CharT> 
        unspecified max_size_decor(std::size_t, 
                                   std::basic_string< CharT > const &);
    }
  }
}

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> 
        class format_named_scope_terminal;
      template<typename FallbackPolicyT, typename CharT, 
               template< typename > class ActorT = phoenix::actor> 
        class format_named_scope_actor;

      // 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 &);
    }
  }
}

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;
    }
  }
}

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> class wrapped_formatter_terminal;
      template<typename FunT, typename CharT, 
               template< typename > class ActorT = phoenix::actor> 
        class wrapped_formatter_actor;
      template<typename FunT> unspecified wrap_formatter(FunT const &);
      template<typename CharT, typename FunT> 
        wrapped_formatter_actor< FunT, CharT > wrap_formatter(FunT const &);
    }
  }
}

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();
    }
  }
}

Andrey Semashev

14.07.2012

The header contains attribute keyword descriptor detection trait.

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

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_)

Andrey Semashev

29.01.2012

The header contains attribute keyword forward declaration.

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

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;
      }
    }
  }
}

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.

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 &);
    }
  }
}

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 > > 
        class channel_severity_filter_terminal;
      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> 
        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 &);
    }
  }
}

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 &);
    }
  }
}

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 &);
    }
  }
}

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 &);
    }
  }
}

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.

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 &);
    }
  }
}

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 &);
    }
  }
}

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;
    }
  }
}

PrevUpHomeNext