Andrey Semashev

15.04.2007

The header contains attribute interface definition.

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

Andrey Semashev

06.08.2010

The header contains utilities for casting between attribute factories.

namespace boost {
  namespace log {
    template<typename T> T attribute_cast(attribute const &);
    namespace attributes {
      class cast_source;
    }
  }
}

Andrey Semashev

28.06.2010

The header contains attribute name interface definition.

namespace boost {
  namespace log {
    class attribute_name;
    template<typename CharT, typename TraitsT> 
      std::basic_ostream< CharT, TraitsT > & 
      operator<<(std::basic_ostream< CharT, TraitsT > &, 
                 attribute_name const &);
  }
}

Andrey Semashev

08.03.2007

This header contains definition of the attribute set container.

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

Andrey Semashev

21.05.2010

The header contains attribute_value class definition.

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

Andrey Semashev

24.06.2007

The header contains an implementation of a basic attribute value implementation class.

namespace boost {
  namespace log {
    namespace attributes {
      template<typename T> class attribute_value_impl;
      template<typename T> attribute_value make_attribute_value(T &&);
    }
  }
}

Andrey Semashev

21.04.2007

This header file contains definition of attribute value set. The set is constructed from three attribute sets (global, thread-specific and source-specific) and contains attribute values.

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

Andrey Semashev

01.12.2007

The header contains wall clock attribute implementation and typedefs.

namespace boost {
  namespace log {
    namespace attributes {
      template<typename TimeTraitsT> class basic_clock;

      typedef basic_clock< utc_time_traits > utc_clock;  // Attribute that returns current UTC time. 
      typedef basic_clock< local_time_traits > local_clock;  // Attribute that returns current local time. 
    }
  }
}

Andrey Semashev

15.04.2007

The header contains implementation of a constant attribute.

namespace boost {
  namespace log {
    namespace attributes {
      template<typename T> class constant;
      template<typename T> unspecified make_constant(BOOST_FWD_REF(T));
    }
  }
}

Andrey Semashev

01.05.2007

The header contains implementation of the counter attribute.

namespace boost {
  namespace log {
    namespace attributes {
      template<typename T> class counter;
    }
  }
}

Andrey Semashev

12.09.2009

The header contains implementation of a current process id attribute

namespace boost {
  namespace log {
    typedef unspecified process_id;  // Process identifier type used by the library. 
    namespace attributes {
      class current_process_id;
    }
  }
}

Andrey Semashev

29.07.2012

The header contains implementation of a current process name attribute

namespace boost {
  namespace log {
    namespace attributes {
      class current_process_name;
    }
  }
}

Andrey Semashev

12.09.2009

The header contains implementation of a current thread id attribute

namespace boost {
  namespace log {
    typedef unspecified thread_id;  // Thread identifier type. 
    namespace attributes {
      class current_thread_id;
    }
  }
}

Andrey Semashev

18.08.2012

The header contains definition of fallback policies when attribute value visitation or extraction fails.

namespace boost {
  namespace log {
    template<typename DefaultT> struct fallback_to_default;
    struct fallback_to_none;
    struct fallback_to_throw;
  }
}

Andrey Semashev

18.08.2012

The header contains forward declaration of fallback policies when attribute value visitation or extraction fails.

Andrey Semashev

24.06.2007

The header contains implementation of an attribute that calls a third-party function on value acquisition.

namespace boost {
  namespace log {
    namespace attributes {
      template<typename R> class function;
      template<typename T> 
        function< typename remove_cv< typename remove_reference< typename boost::result_of< T() >::type >::type >::type > 
        make_function(T const &);
    }
  }
}

Andrey Semashev

06.11.2007

The header contains implementation of a mutable constant attribute.

namespace boost {
  namespace log {
    namespace attributes {
      template<typename T, typename MutexT = void, 
               typename ScopedWriteLockT = auto, 
               typename ScopedReadLockT = auto> 
        class mutable_constant;

      template<typename T> class mutable_constant<T, void, void, void>;
    }
  }
}

Andrey Semashev

24.06.2007

The header contains implementation of named scope container and an attribute that allows to put the named scope to log. A number of convenience macros are also provided.

BOOST_LOG_NAMED_SCOPE(name)
BOOST_LOG_FUNCTION()
BOOST_LOG_FUNC()

namespace boost {
  namespace log {
    namespace attributes {
      class named_scope;

      struct named_scope_entry;

      class named_scope_list;
      template<typename CharT, typename TraitsT> 
        std::basic_ostream< CharT, TraitsT > & 
        operator<<(std::basic_ostream< CharT, TraitsT > &, 
                   named_scope_list const &);
    }
  }
}

Andrey Semashev

13.05.2007

The header contains definition of facilities to define scoped attributes.

BOOST_LOG_SCOPED_LOGGER_ATTR(logger, attr_name, attr)
BOOST_LOG_SCOPED_LOGGER_TAG(logger, attr_name, attr_value)
BOOST_LOG_SCOPED_THREAD_ATTR(attr_name, attr)
BOOST_LOG_SCOPED_THREAD_TAG(attr_name, attr_value)

namespace boost {
  namespace log {
    typedef unspecified scoped_attribute;  // Scoped attribute guard type. 
    template<typename LoggerT> 
      unspecified add_scoped_logger_attribute(LoggerT &, 
                                              attribute_name const &, 
                                              attribute const &);
    unspecified add_scoped_thread_attribute(attribute_name const &, 
                                            attribute const &);
  }
}

Andrey Semashev

01.12.2007

The header contains implementation of time traits that are used in various parts of the library to acquire current time.

namespace boost {
  namespace log {
    namespace attributes {
      struct basic_time_traits;
      struct local_time_traits;
      struct utc_time_traits;
    }
  }
}

Andrey Semashev

02.12.2007

The header contains implementation of a stop watch attribute.

namespace boost {
  namespace log {
    namespace attributes {
      class timer;
    }
  }
}

Andrey Semashev

01.03.2008

The header contains implementation of tools for extracting an attribute value from the view.

namespace boost {
  namespace log {
    template<typename T, typename FallbackPolicyT, typename TagT> 
      class value_extractor;
    template<typename T, typename TagT = void> 
      result_of::extract< T, TagT >::type 
      extract(attribute_name const &, attribute_value_set const &);
    template<typename T, typename TagT = void> 
      result_of::extract< T, TagT >::type 
      extract(attribute_name const &, record const &);
    template<typename T, typename TagT = void> 
      result_of::extract< T, TagT >::type 
      extract(attribute_name const &, record_view const &);
    template<typename T, typename TagT = void> 
      result_of::extract< T, TagT >::type extract(attribute_value const &);
    template<typename T, typename TagT = void> 
      result_of::extract_or_throw< T, TagT >::type 
      extract_or_throw(attribute_name const &, attribute_value_set const &);
    template<typename T, typename TagT = void> 
      result_of::extract_or_throw< T, TagT >::type 
      extract_or_throw(attribute_name const &, record const &);
    template<typename T, typename TagT = void> 
      result_of::extract_or_throw< T, TagT >::type 
      extract_or_throw(attribute_name const &, record_view const &);
    template<typename T, typename TagT = void> 
      result_of::extract_or_throw< T, TagT >::type 
      extract_or_throw(attribute_value const &);
    template<typename T, typename TagT = void, typename DefaultT> 
      result_of::extract_or_default< T, DefaultT, TagT >::type 
      extract_or_default(attribute_name const &, attribute_value_set const &, 
                         DefaultT const &);
    template<typename T, typename TagT = void, typename DefaultT> 
      result_of::extract_or_default< T, DefaultT, TagT >::type 
      extract_or_default(attribute_name const &, record const &, 
                         DefaultT const &);
    template<typename T, typename TagT = void, typename DefaultT> 
      result_of::extract_or_default< T, DefaultT, TagT >::type 
      extract_or_default(attribute_name const &, record_view const &, 
                         DefaultT const &);
    template<typename T, typename TagT = void, typename DefaultT> 
      result_of::extract_or_default< T, DefaultT, TagT >::type 
      extract_or_default(attribute_value const &, DefaultT const &);
    template<typename DescriptorT, template< typename > class ActorT> 
      result_of::extract< typenameDescriptorT::value_type, DescriptorT >::type 
      extract(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
              attribute_value_set const &);
    template<typename DescriptorT, template< typename > class ActorT> 
      result_of::extract< typenameDescriptorT::value_type, DescriptorT >::type 
      extract(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
              record const &);
    template<typename DescriptorT, template< typename > class ActorT> 
      result_of::extract< typenameDescriptorT::value_type, DescriptorT >::type 
      extract(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
              record_view const &);
    template<typename DescriptorT, template< typename > class ActorT> 
      result_of::extract_or_throw< typenameDescriptorT::value_type, DescriptorT >::type 
      extract_or_throw(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
                       attribute_value_set const &);
    template<typename DescriptorT, template< typename > class ActorT> 
      result_of::extract_or_throw< typenameDescriptorT::value_type, DescriptorT >::type 
      extract_or_throw(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
                       record const &);
    template<typename DescriptorT, template< typename > class ActorT> 
      result_of::extract_or_throw< typenameDescriptorT::value_type, DescriptorT >::type 
      extract_or_throw(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
                       record_view const &);
    template<typename DescriptorT, template< typename > class ActorT, 
             typename DefaultT> 
      result_of::extract_or_default< typenameDescriptorT::value_type, DefaultT, DescriptorT >::type 
      extract_or_default(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
                         attribute_value_set const &, DefaultT const &);
    template<typename DescriptorT, template< typename > class ActorT, 
             typename DefaultT> 
      result_of::extract_or_default< typenameDescriptorT::value_type, DefaultT, DescriptorT >::type 
      extract_or_default(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
                         record const &, DefaultT const &);
    template<typename DescriptorT, template< typename > class ActorT, 
             typename DefaultT> 
      result_of::extract_or_default< typenameDescriptorT::value_type, DefaultT, DescriptorT >::type 
      extract_or_default(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
                         record_view const &, DefaultT const &);
    namespace result_of {
      template<typename T, typename TagT> struct extract;
      template<typename T, typename DefaultT, typename TagT> 
        struct extract_or_default;
      template<typename T, typename TagT> struct extract_or_throw;
    }
  }
}

Andrey Semashev

01.03.2008

The header contains forward declaration of tools for extracting attribute values from the view.

Andrey Semashev

01.03.2008

The header contains implementation of convenience tools to apply visitors to an attribute value in the view.

namespace boost {
  namespace log {
    template<typename T, typename FallbackPolicyT> class value_visitor_invoker;
    class visitation_result;
    template<typename T, typename VisitorT> 
      visitation_result 
      visit(attribute_name const &, attribute_value_set const &, VisitorT);
    template<typename T, typename VisitorT> 
      visitation_result 
      visit(attribute_name const &, record const &, VisitorT);
    template<typename T, typename VisitorT> 
      visitation_result 
      visit(attribute_name const &, record_view const &, VisitorT);
    template<typename T, typename VisitorT> 
      visitation_result visit(attribute_value const &, VisitorT);
    template<typename DescriptorT, template< typename > class ActorT, 
             typename VisitorT> 
      visitation_result 
      visit(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
            attribute_value_set const &, VisitorT);
    template<typename DescriptorT, template< typename > class ActorT, 
             typename VisitorT> 
      visitation_result 
      visit(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
            record const &, VisitorT);
    template<typename DescriptorT, template< typename > class ActorT, 
             typename VisitorT> 
      visitation_result 
      visit(expressions::attribute_keyword< DescriptorT, ActorT > const &, 
            record_view const &, VisitorT);
  }
}

Andrey Semashev

01.03.2008

The header contains forward declaration of convenience tools to apply visitors to an attribute value in the view.