Andrey Semashev

14.07.2009

The header contains implementation of asynchronous sink frontent.

BOOST_LOG_SINKS_ASYNC_FRONTEND_HPP_INCLUDED_
BOOST_LOG_SINK_CTOR_FORWARD_INTERNAL(z, n, types)

namespace boost {
  namespace log {
    namespace sinks {
      template<typename SinkBackendT> class asynchronous_sink;
    }
  }
}

Andrey Semashev

07.11.2008

The header contains facilities that are used in different sinks to map attribute values used throughout the application to values used with the specific native logging API. These tools are mostly needed to map application severity levels on native levels, required by OS-specific sink backends.

BOOST_LOG_SINKS_ATTRIBUTE_MAPPING_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT, typename MappedT> struct basic_mapping;

      template<typename CharT, typename MappedT, 
               typename AttributeValueT = int> 
        class basic_direct_mapping;
      template<typename CharT, typename MappedT, 
               typename AttributeValueT = int> 
        class basic_custom_mapping;
    }
  }
}

Andrey Semashev

04.11.2007

The header contains implementation of base classes for sink backends.

BOOST_LOG_SINKS_BASIC_SINK_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT, typename ThreadingModelTagT> 
        struct basic_sink_backend;

      template<typename CharT, typename TargetCharT = CharT, 
               typename ThreadingModelTagT = frontend_synchronization_tag> 
        class basic_formatting_sink_backend;
    }
  }
}

Andrey Semashev

14.07.2009

The header contains implementation of a base class for sink frontends.

BOOST_LOG_SINKS_BASIC_SINK_FRONTEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_sink_frontend;
    }
  }
}

Andrey Semashev

07.11.2008

The header contains a logging sink backend that outputs log records to the debugger.

BOOST_LOG_SINKS_DEBUG_OUTPUT_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_debug_output_backend;
    }
  }
}

Andrey Semashev

07.11.2008

The header contains a logging sink backend that uses Windows NT event log API for signaling application events.

BOOST_LOG_SINKS_EVENT_LOG_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_simple_event_log_backend;
      template<typename CharT> class basic_event_log_backend;
      namespace event_log {
        template<typename CharT, typename AttributeValueT = int> 
          class basic_direct_event_type_mapping;
        template<typename CharT, typename AttributeValueT = int> 
          class basic_custom_event_type_mapping;
        template<typename CharT, typename AttributeValueT = int> 
          class basic_direct_event_id_mapping;
        template<typename CharT, typename AttributeValueT = int> 
          class basic_custom_event_id_mapping;
        template<typename CharT, typename AttributeValueT = int> 
          class basic_direct_event_category_mapping;
        template<typename CharT, typename AttributeValueT = int> 
          class basic_custom_event_category_mapping;
        template<typename CharT> class basic_event_composer;

        // Event log source registration modes. 
        enum registration_mode { never, on_demand, forced };
      }
    }
  }
}

Andrey Semashev

07.11.2008

The header contains definition of constants related to Windows NT Event Log API. The constants can be used in other places without the event log backend.

BOOST_LOG_SINKS_EVENT_LOG_CONSTANTS_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      namespace event_log {
        typedef unspecified event_id_t;  // A tagged integral type that represents event identifier for the Windows API. 
        typedef unspecified event_category_t;  // A tagged integral type that represents event category for the Windows API. 
        typedef unspecified event_type_t;  // A tagged integral type that represents log record level for the Windows API. 

        const event_type_t success;        // Equivalent to EVENTLOG_SUCCESS. 
        const event_type_t info;        // Equivalent to EVENTLOG_INFORMATION_TYPE. 
        const event_type_t warning;        // Equivalent to EVENTLOG_WARNING_TYPE. 
        const event_type_t error;        // Equivalent to EVENTLOG_ERROR_TYPE. 
        event_id_t make_event_id(unsigned int);
        event_category_t make_event_category(unsigned short);
        event_type_t make_event_type(unsigned short);
      }
    }
  }
}

Andrey Semashev

23.08.2009

The header contains implementation of asynchronous sink frontent with log record ordering capability.

BOOST_LOG_SINKS_ORDERING_ASYNC_FRONTEND_HPP_INCLUDED_
BOOST_LOG_SINK_CTOR_FORWARD_INTERNAL(z, n, types)

namespace boost {
  namespace log {
    namespace sinks {
      template<typename SinkBackendT> class ordering_asynchronous_sink;
    }
  }
}

Andrey Semashev

22.04.2007

The header contains an interface declaration for all sinks. This interface is used by the logging core to feed log records to sinks.

BOOST_LOG_SINKS_SINK_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class sink;
    }
  }
}

Andrey Semashev

14.07.2009

The header contains implementation of synchronous sink frontend.

BOOST_LOG_SINKS_SYNC_FRONTEND_HPP_INCLUDED_
BOOST_LOG_SINK_CTOR_FORWARD_INTERNAL(z, n, data)

namespace boost {
  namespace log {
    namespace sinks {
      template<typename SinkBackendT> class synchronous_sink;
    }
  }
}

Andrey Semashev

08.01.2008

The header contains implementation of a Syslog sink backend along with its setup facilities.

BOOST_LOG_SINKS_SYSLOG_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_syslog_backend;

      // Supported IP protocol versions. 
      enum ip_versions { v4, v6 };
      namespace syslog {
        template<typename CharT, typename AttributeValueT = int> 
          class basic_direct_severity_mapping;
        template<typename CharT, typename AttributeValueT = int> 
          class basic_custom_severity_mapping;

        // The enumeration defined the possible implementation types for the syslog backend. 
        enum impl_types { native =  0, udp_socket_based =  1 };
      }
    }
  }
}

Andrey Semashev

08.01.2008

The header contains definition of constants related to Syslog API. The constants can be used in other places without the Syslog backend.

BOOST_LOG_SINKS_SYSLOG_CONSTANTS_HPP_INCLUDED_HPP_

namespace boost {
  namespace log {
    namespace sinks {
      namespace syslog {
        typedef unspecified level_t;  // A tagged integal type that represents log record level for the syslog API. 
        typedef unspecified facility_t;  // A tagged integal type that represents log source facility for the syslog API. 

        const level_t emergency;        // Equivalent to LOG_EMERG in syslog API. 
        const level_t alert;        // Equivalent to LOG_ALERT in syslog API. 
        const level_t critical;        // Equivalent to LOG_CRIT in syslog API. 
        const level_t error;        // Equivalent to LOG_ERROR in syslog API. 
        const level_t warning;        // Equivalent to LOG_WARNING in syslog API. 
        const level_t notice;        // Equivalent to LOG_NOTICE in syslog API. 
        const level_t info;        // Equivalent to LOG_INFO in syslog API. 
        const level_t debug;        // Equivalent to LOG_DEBUG in syslog API. 
        const facility_t kernel;        // Kernel messages. 
        const facility_t user;        // User-level messages. Equivalent to LOG_USER in syslog API. 
        const facility_t mail;        // Mail system messages. Equivalent to LOG_MAIL in syslog API. 
        const facility_t daemon;        // System daemons. Equivalent to LOG_DAEMON in syslog API. 
        const facility_t security0;        // Security/authorization messages. 
        const facility_t syslogd;        // Messages from the syslogd daemon. Equivalent to LOG_SYSLOG in syslog API. 
        const facility_t printer;        // Line printer subsystem. Equivalent to LOG_LPR in syslog API. 
        const facility_t news;        // Network news subsystem. Equivalent to LOG_NEWS in syslog API. 
        const facility_t uucp;        // Messages from UUCP subsystem. Equivalent to LOG_UUCP in syslog API. 
        const facility_t clock0;        // Messages from the clock daemon. 
        const facility_t security1;        // Security/authorization messages. 
        const facility_t ftp;        // Messages from FTP daemon. 
        const facility_t ntp;        // Messages from NTP daemon. 
        const facility_t log_audit;        // Security/authorization messages. 
        const facility_t log_alert;        // Security/authorization messages. 
        const facility_t clock1;        // Messages from the clock daemon. 
        const facility_t local0;        // For local use. Equivalent to LOG_LOCAL0 in syslog API. 
        const facility_t local1;        // For local use. Equivalent to LOG_LOCAL1 in syslog API. 
        const facility_t local2;        // For local use. Equivalent to LOG_LOCAL2 in syslog API. 
        const facility_t local3;        // For local use. Equivalent to LOG_LOCAL3 in syslog API. 
        const facility_t local4;        // For local use. Equivalent to LOG_LOCAL4 in syslog API. 
        const facility_t local5;        // For local use. Equivalent to LOG_LOCAL5 in syslog API. 
        const facility_t local6;        // For local use. Equivalent to LOG_LOCAL6 in syslog API. 
        const facility_t local7;        // For local use. Equivalent to LOG_LOCAL7 in syslog API. 
        level_t make_level(int);
        facility_t make_facility(int);
      }
    }
  }
}

Andrey Semashev

09.06.2009

The header contains implementation of a text file sink backend.

BOOST_LOG_SINKS_TEXT_FILE_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_text_file_backend;
      namespace file {
        struct collector;

        class rotation_at_time_point;
        class rotation_at_time_interval;

        // The enumeration of the stored files scan methods. 
        enum scan_method { no_scan, scan_matching, scan_all };
        template<typename... ArgsT> 
          shared_ptr< collector > make_collector(ArgsT...const &);
      }
    }
  }
}

Andrey Semashev

09.06.2009

The header contains implementation of a text multi-file sink backend.

BOOST_LOG_SINKS_TEXT_MULTIFILE_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_text_multifile_backend;
      namespace file {
        template<typename FormatterT> class file_name_composer_adapter;
        template<typename FormatterT> 
          file_name_composer_adapter< FormatterT > 
          as_file_name_composer(FormatterT const &, 
                                std::locale const & = std::locale());
      }
    }
  }
}

Andrey Semashev

22.04.2007

The header contains implementation of a text output stream sink backend.

BOOST_LOG_SINKS_TEXT_OSTREAM_BACKEND_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      template<typename CharT> class basic_text_ostream_backend;
    }
  }
}

Andrey Semashev

22.04.2007

The header contains definition of threading models. These models are used to ensure thread safety protocol between sink backends and frontents.

BOOST_LOG_SINKS_THREADING_MODELS_HPP_INCLUDED_

namespace boost {
  namespace log {
    namespace sinks {
      struct threading_model_tag;
      struct single_thread_tag;
      struct frontend_synchronization_tag;
      struct backend_synchronization_tag;
      template<typename TestedT, typename RequiredT> struct is_model_supported;
    }
  }
}

Andrey Semashev

14.07.2009

The header contains implementation of an unlocked sink frontend.

BOOST_LOG_SINKS_UNLOCKED_FRONTEND_HPP_INCLUDED_
BOOST_LOG_SINK_CTOR_FORWARD_INTERNAL(z, n, types)

namespace boost {
  namespace log {
    namespace sinks {
      template<typename SinkBackendT> class unlocked_sink;
    }
  }
}