Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Expressions

Boost , Chapter 1. Boost.Log v2 , Reference

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>

Андрей Семашев

21.07.2012

Заголовок содержит реализацию общего заполнителя атрибутов в выражениях шаблонов.

namespace boost {
  namespace log {
    namespace expressions {
      template<typename T, typename FallbackPolicyT, typename TagT> 
        class attribute_terminal;
      template<typename T, typename FallbackPolicyT, typename TagT, 
               template< typename > class ActorT> 
        class attribute_actor;
      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 &);
    }
  }
}

Андрей Семашев

21.07.2012

Заголовок содержит прямое объявление общего заполнителя атрибута в выражениях шаблона.

Андрей Семашев

13.07.2012

Заголовок содержит определение объекта функции фильтра.

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

Андрей Семашев

13.07.2012

Заголовок содержит определение объекта функции форматера.

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

Андрей Семашев

10.11.2012

Заголовок включает в себя все шаблонные формататоры выражения.

Андрей Семашев

18.11.2012

Заголовок содержит реализацию декораторов персонажей в стиле C.

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

Андрей Семашев

17.11.2012

Заголовок содержит реализацию декоратора персонажа.

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

Андрей Семашев

18.11.2012

Заголовок содержит реализацию декоратора персонажей в стиле CSV. Смотри: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();
    }
  }
}

Андрей Семашев

16.09.2012

Заголовок содержит функцию форматирования для значений атрибутов даты и времени.

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

Андрей Семашев

15.11.2012

Заголовок содержит общую функцию форматирования записи журнала.

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

Андрей Семашев

17.11.2012

Заголовок содержит реализацию условного форматтера.

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

Андрей Семашев

06.07.2016

Заголовок содержит реализацию ограничителя длины строки.

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

Андрей Семашев

11.11.2012

Заголовок содержит функцию форматировщика для названных значений атрибутов объема.

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

Андрей Семашев

24.07.2012

Заголовок содержит реализацию заполнителя потока в выражениях шаблонов.

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

Андрей Семашев

24.11.2012

Заголовок содержит обертку функции форматировщика, которая позволяет сторонним функциям участвовать в выражениях форматирования.

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

Андрей Семашев

18.11.2012

Заголовок содержит реализацию декоратора символов в стиле XML.

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

Андрей Семашев

14.07.2012

Заголовок содержит атрибут ключевого слова дескриптор обнаружения признака.

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

Андрей Семашев

29.01.2012

Заголовок содержит объявление атрибута ключевого слова.

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

Андрей Семашев

29.01.2012

Заголовок содержит объявление атрибута keyword forward.

Андрей Семашев

13.07.2012

Заголовок содержит объявление ключевого слова log.

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

Андрей Семашев

29.01.2012

Заголовок включает в себя все предикаты выражения шаблона.

Андрей Семашев

02.09.2012

Заголовок содержит реализацию предиката<begins_with>в шаблонных выражениях.

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

Андрей Семашев

25.11.2012

Заголовок содержит реализацию минимальной строгости на фильтр канала.

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

Андрей Семашев

02.09.2012

Заголовок содержит реализацию предиката<contains>в шаблонных выражениях.

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

Андрей Семашев

02.09.2012

Заголовок содержит реализацию предиката<ends_with>в шаблонных выражениях.

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

Андрей Семашев

23.07.2012

Заголовок содержит реализацию общей проверки присутствия атрибутов в выражениях шаблонов.

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

Андрей Семашев

05.12.2012

Заголовок содержит реализацию предиката<is_debugger_present>в шаблонных выражениях.

Андрей Семашев

02.09.2012

Заголовок содержит реализацию<is_in_range>предиката в шаблонных выражениях.

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

Андрей Семашев

02.09.2012

Заголовок содержит реализацию<matches>предиката в шаблонных выражениях.

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

Андрей Семашев

25.07.2012

Заголовок содержит реализацию заполнителя записи журнала в выражениях шаблонов.

namespace boost {
  namespace log {
    namespace expressions {
      typedef phoenix::expression::argument< 1 >::type record_type;
      const record_type record;
    }
  }
}
Copyright © 2007-2016 Andrey Semashev

Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию по адресуhttp://www.boost.org/LICENSE_1_0.txt).

PrevUpHomeNext

Статья Expressions раздела Chapter 1. Boost.Log v2 Reference может быть полезна для разработчиков на c++ и boost.




Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.


:: Главная :: Reference ::

реклама
©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 19:19:39/0.034403800964355/1