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, 
               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> 
        class basic_logger;
      template<typename CharT, typename FinalT, typename ThreadingModelT> 
        void swap(basic_logger< CharT, FinalT, ThreadingModelT > &, 
                  basic_logger< CharT, FinalT, ThreadingModelT > &);
    }
  }
}

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

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

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

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

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)

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

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

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

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

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

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 {
      template<typename MutexT> struct multi_thread_model;
      struct single_thread_model;
      void swap(single_thread_model &, single_thread_model &);
      template<typename MutexT> 
        void swap(multi_thread_model< MutexT > &, 
                  multi_thread_model< MutexT > &);
    }
  }
}