### Logging sources

#### Header <boost/log/sources/basic_logger.hpp>

Andrey Semashev

08.03.2007

The header contains implementation of a base class for loggers. Convenience macros for defining custom loggers are also provided.

    BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS(class_type)
    BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS_TEMPLATE(class_type)
    BOOST_LOG_FORWARD_LOGGER_ASSIGNMENT(class_type)
    BOOST_LOG_FORWARD_LOGGER_ASSIGNMENT_TEMPLATE(class_type)
    BOOST_LOG_FORWARD_LOGGER_MEMBERS(class_type)
    BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(class_type)
    BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, char_type, base_seq, threading)
    BOOST_LOG_DECLARE_LOGGER(type_name, base_seq)
    BOOST_LOG_DECLARE_LOGGER_MT(type_name, base_seq)
    BOOST_LOG_DECLARE_WLOGGER(type_name, base_seq)
    BOOST_LOG_DECLARE_WLOGGER_MT(type_name, base_seq)

    namespace boost {
      namespace log {
        namespace sources {
          template<typename CharT, typename FinalT, typename ThreadingModelT>
            class basic_logger;
          template<typename CharT, typename FinalT, typename ThreadingModelT,
                   typename FeaturesT>
            class basic_composite_logger;

          template<typename CharT, typename FinalT, typename FeaturesT>
            class basic_composite_logger<CharT, FinalT, single_thread_model, FeaturesT>;
          template<typename CharT, typename FinalT, typename ThreadingModelT>
            void swap(basic_logger< CharT, FinalT, ThreadingModelT > &,
                      basic_logger< CharT, FinalT, ThreadingModelT > &);
        }
      }
    }

#### Header <boost/log/sources/channel_feature.hpp>

Andrey Semashev

28.02.2008

The header contains implementation of a channel support feature.

    BOOST_LOG_STREAM_CHANNEL(logger, chan)
    BOOST_LOG_CHANNEL(logger, chan)

    namespace boost {
      namespace log {
        namespace sources {
          template<typename BaseT, typename ChannelT> class basic_channel_logger;

          template<typename ChannelT = std::string> struct channel;
        }
      }
    }

#### Header <boost/log/sources/channel_logger.hpp>

Andrey Semashev

28.02.2008

The header contains implementation of a logger with channel support.

    namespace boost {
      namespace log {
        namespace sources {
          template<typename ChannelT = std::string> class channel_logger;
          template<typename ChannelT = std::string> class channel_logger_mt;
          template<typename ChannelT = std::wstring> class wchannel_logger;
          template<typename ChannelT = std::wstring> class wchannel_logger_mt;
        }
      }
    }

#### Header <boost/log/sources/exception_handler_feature.hpp>

Andrey Semashev

17.07.2009

The header contains implementation of an exception handler support feature.

    namespace boost {
      namespace log {
        namespace sources {
          template<typename BaseT> class basic_exception_handler_logger;

          struct exception_handler;
        }
      }
    }

#### Header <boost/log/sources/features.hpp>

Andrey Semashev

17.07.2009

The header contains definition of a features list class template.

    namespace boost {
      namespace log {
        namespace sources {
          template<typename... FeaturesT> struct features;
        }
      }
    }

#### Header <boost/log/sources/global_logger_storage.hpp>

Andrey Semashev

21.04.2008

The header contains implementation of facilities to declare global loggers.

    BOOST_LOG_GLOBAL_LOGGER(tag_name, logger)
    BOOST_LOG_GLOBAL_LOGGER_INIT(tag_name, logger)
    BOOST_LOG_GLOBAL_LOGGER_DEFAULT(tag_name, logger)
    BOOST_LOG_GLOBAL_LOGGER_CTOR_ARGS(tag_name, logger, args)
    BOOST_LOG_INLINE_GLOBAL_LOGGER_INIT(tag_name, logger)
    BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(tag_name, logger)
    BOOST_LOG_INLINE_GLOBAL_LOGGER_CTOR_ARGS(tag_name, logger, args)

#### Header <boost/log/sources/logger.hpp>

Andrey Semashev

08.03.2007

The header contains implementation of a simplistic logger with no features.

    namespace boost {
      namespace log {
        namespace sources {
          class logger;
          class logger_mt;
          class wlogger;
          class wlogger_mt;
        }
      }
    }

#### Header <boost/log/sources/record_ostream.hpp>

Andrey Semashev

09.03.2009

This header contains a wrapper class around a logging record that allows to compose the record message with a streaming expression.

    BOOST_LOG_STREAM(logger)
    BOOST_LOG_STREAM_WITH_PARAMS(logger, params_seq)
    BOOST_LOG(logger)
    BOOST_LOG_WITH_PARAMS(logger, params_seq)

    namespace boost {
      namespace log {
        template<typename CharT> class basic_record_ostream;

        typedef basic_record_ostream< char > record_ostream;  // Convenience typedef for narrow-character logging.
        typedef basic_record_ostream< wchar_t > wrecord_ostream;  // Convenience typedef for wide-character logging.
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &, T);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &, T const &);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &, T &);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &&, T);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &&, T const &);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &&, T &);
      }
    }

#### Header <boost/log/sources/severity_channel_logger.hpp>

Andrey Semashev

28.02.2008

The header contains implementation of a logger with severity level and channel support.

    BOOST_LOG_STREAM_CHANNEL_SEV(logger, chan, lvl)
    BOOST_LOG_CHANNEL_SEV(logger, chan, lvl)

    namespace boost {
      namespace log {
        namespace sources {
          template<typename LevelT = int, typename ChannelT = std::string>
            class severity_channel_logger;
          template<typename LevelT = int, typename ChannelT = std::string>
            class severity_channel_logger_mt;
          template<typename LevelT = int, typename ChannelT = std::wstring>
            class wseverity_channel_logger;
          template<typename LevelT = int, typename ChannelT = std::wstring>
            class wseverity_channel_logger_mt;
        }
      }
    }

#### Header <boost/log/sources/severity_feature.hpp>

Andrey Semashev

08.03.2007

The header contains implementation of a severity level support feature.

    BOOST_LOG_STREAM_SEV(logger, lvl)
    BOOST_LOG_SEV(logger, lvl)

    namespace boost {
      namespace log {
        namespace sources {
          template<typename BaseT, typename LevelT = int> class basic_severity_logger;

          template<typename LevelT = int> struct severity;
        }
      }
    }

#### Header <boost/log/sources/severity_logger.hpp>

Andrey Semashev

08.03.2007

The header contains implementation of a logger with severity level support.

    namespace boost {
      namespace log {
        namespace sources {
          template<typename LevelT = int> class severity_logger;
          template<typename LevelT = int> class severity_logger_mt;
          template<typename LevelT = int> class wseverity_logger;
          template<typename LevelT = int> class wseverity_logger_mt;
        }
      }
    }

#### Header <boost/log/sources/threading_models.hpp>

Andrey Semashev

04.10.2008

The header contains definition of threading models that can be used in loggers. The header also provides a number of tags that can be used to express lock requirements on a function callee.

    namespace boost {
      namespace log {
        namespace sources {
          struct single_thread_model;
          template<typename MutexT> struct multi_thread_model;
        }
      }
    }