### Attributes

#### Header <boost/log/attributes/attribute.hpp>

Andrey Semashev

15.04.2007

The header contains attribute interface definition.

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

#### Header <boost/log/attributes/attribute_cast.hpp>

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

#### Header <boost/log/attributes/attribute_name.hpp>

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

#### Header <boost/log/attributes/attribute_set.hpp>

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

#### Header <boost/log/attributes/attribute_value.hpp>

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

#### Header <boost/log/attributes/attribute_value_impl.hpp>

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

#### Header <boost/log/attributes/attribute_value_set.hpp>

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

#### Header <boost/log/attributes/clock.hpp>

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

#### Header <boost/log/attributes/constant.hpp>

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

#### Header <boost/log/attributes/counter.hpp>

Andrey Semashev

01.05.2007

The header contains implementation of the counter attribute.

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

#### Header <boost/log/attributes/current_process_id.hpp>

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

#### Header <boost/log/attributes/current_process_name.hpp>

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

#### Header <boost/log/attributes/current_thread_id.hpp>

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

#### Header <boost/log/attributes/fallback_policy.hpp>

Andrey Semashev

18.08.2012

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

    namespace boost {
      namespace log {
        struct fallback_to_none;
        struct fallback_to_throw;
      }
    }

#### Header <boost/log/attributes/fallback_policy_fwd.hpp>

Andrey Semashev

18.08.2012

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

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

#### Header <boost/log/attributes/function.hpp>

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

#### Header <boost/log/attributes/mutable_constant.hpp>

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

#### Header <boost/log/attributes/named_scope.hpp>

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

#### Header <boost/log/attributes/scoped_attribute.hpp>

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

#### Header <boost/log/attributes/time_traits.hpp>

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

#### Header <boost/log/attributes/timer.hpp>

Andrey Semashev

02.12.2007

The header contains implementation of a stop watch attribute.

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

#### Header <boost/log/attributes/value_extraction.hpp>

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 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< typename DescriptorT::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< typename DescriptorT::value_type, DescriptorT >::type
          extract(expressions::attribute_keyword< DescriptorT, ActorT > const &,
                  record const &);
        template<typename DescriptorT, template< typename > class ActorT>
          result_of::extract< typename DescriptorT::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< typename DescriptorT::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< typename DescriptorT::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< typename DescriptorT::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< typename DescriptorT::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< typename DescriptorT::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< typename DescriptorT::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;
        }
      }
    }

#### Header <boost/log/attributes/value_extraction_fwd.hpp>

Andrey Semashev

01.03.2008

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

#### Header <boost/log/attributes/value_visitation.hpp>

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

#### Header <boost/log/attributes/value_visitation_fwd.hpp>

Andrey Semashev

01.03.2008

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