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 {
    struct fallback_to_none;
    struct fallback_to_throw;
    template<typename DefaultT> struct fallback_to_default;
  }
}

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

namespace boost {
  namespace log {
    namespace attributes {
      struct named_scope_entry;

      class named_scope_list;
      class named_scope;
      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 utc_time_traits;
      struct local_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 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 {
    }
  }
}

Andrey Semashev

01.03.2008

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

namespace boost {
  namespace log {
    template<typename T, typename FallbackPolicyT = fallback_to_none, 
             typename TagT = void> 
      class value_extractor;
    namespace result_of {
      template<typename T, typename DefaultT = T, typename TagT = void> 
        struct extract_or_default;
      template<typename T, typename TagT = void> struct extract_or_throw;
      template<typename T, typename TagT = void> struct extract;
    }
  }
}

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 FallbackPolicyT> class value_visitor_invoker;
    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.