1 /* 2 * Copyright Andrey Semashev 2007 - 2015. 3 * Distributed under the Boost Software License, Version 1.0. 4 * (See accompanying file LICENSE_1_0.txt or copy at 5 * http://www.boost.org/LICENSE_1_0.txt) 6 */ 7 /*! 8 * \file channel_logger.hpp 9 * \author Andrey Semashev 10 * \date 28.02.2008 11 * 12 * The header contains implementation of a logger with channel support. 13 */ 14 15 #ifndef BOOST_LOG_SOURCES_CHANNEL_LOGGER_HPP_INCLUDED_ 16 #define BOOST_LOG_SOURCES_CHANNEL_LOGGER_HPP_INCLUDED_ 17 18 #include <boost/log/detail/config.hpp> 19 #if !defined(BOOST_LOG_NO_THREADS) 20 #include <boost/log/detail/light_rw_mutex.hpp> 21 #endif // !defined(BOOST_LOG_NO_THREADS) 22 #include <boost/log/sources/features.hpp> 23 #include <boost/log/sources/basic_logger.hpp> 24 #include <boost/log/sources/threading_models.hpp> 25 #include <boost/log/sources/channel_feature.hpp> 26 #include <boost/log/keywords/channel.hpp> 27 #include <boost/log/detail/header.hpp> 28 29 #ifdef BOOST_HAS_PRAGMA_ONCE 30 #pragma once 31 #endif 32 33 namespace boost { 34 35 BOOST_LOG_OPEN_NAMESPACE 36 37 namespace sources { 38 39 #ifndef BOOST_LOG_DOXYGEN_PASS 40 41 #ifdef BOOST_LOG_USE_CHAR 42 43 //! Narrow-char logger with channel support 44 template< typename ChannelT = std::string > 45 class channel_logger : 46 public basic_composite_logger< 47 char, 48 channel_logger< ChannelT >, 49 single_thread_model, 50 features< channel< ChannelT > > 51 > 52 { 53 typedef typename channel_logger::logger_base base_type; 54 55 public: 56 BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(channel_logger) 57 channel_logger(ChannelT const & channel)58 explicit channel_logger(ChannelT const& channel) : base_type(keywords::channel = channel) 59 { 60 } 61 }; 62 63 #if !defined(BOOST_LOG_NO_THREADS) 64 65 //! Narrow-char thread-safe logger with channel support 66 template< typename ChannelT = std::string > 67 class channel_logger_mt : 68 public basic_composite_logger< 69 char, 70 channel_logger_mt< ChannelT >, 71 multi_thread_model< boost::log::aux::light_rw_mutex >, 72 features< channel< ChannelT > > 73 > 74 { 75 typedef typename channel_logger_mt::logger_base base_type; 76 77 public: 78 BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(channel_logger_mt) 79 channel_logger_mt(ChannelT const & channel)80 explicit channel_logger_mt(ChannelT const& channel) : base_type(keywords::channel = channel) 81 { 82 } 83 }; 84 85 #endif // !defined(BOOST_LOG_NO_THREADS) 86 87 #endif // BOOST_LOG_USE_CHAR 88 89 #ifdef BOOST_LOG_USE_WCHAR_T 90 91 //! Wide-char logger with channel support 92 template< typename ChannelT = std::wstring > 93 class wchannel_logger : 94 public basic_composite_logger< 95 wchar_t, 96 wchannel_logger< ChannelT >, 97 single_thread_model, 98 features< channel< ChannelT > > 99 > 100 { 101 typedef typename wchannel_logger::logger_base base_type; 102 103 public: 104 BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(wchannel_logger) 105 wchannel_logger(ChannelT const & channel)106 explicit wchannel_logger(ChannelT const& channel) : base_type(keywords::channel = channel) 107 { 108 } 109 }; 110 111 #if !defined(BOOST_LOG_NO_THREADS) 112 113 //! Wide-char thread-safe logger with channel support 114 template< typename ChannelT = std::wstring > 115 class wchannel_logger_mt : 116 public basic_composite_logger< 117 wchar_t, 118 wchannel_logger< ChannelT >, 119 multi_thread_model< boost::log::aux::light_rw_mutex >, 120 features< channel< ChannelT > > 121 > 122 { 123 typedef typename wchannel_logger_mt::logger_base base_type; 124 125 public: 126 BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(wchannel_logger_mt) 127 wchannel_logger_mt(ChannelT const & channel)128 explicit wchannel_logger_mt(ChannelT const& channel) : base_type(keywords::channel = channel) 129 { 130 } 131 }; 132 133 #endif // !defined(BOOST_LOG_NO_THREADS) 134 135 #endif // BOOST_LOG_USE_WCHAR_T 136 137 #else // BOOST_LOG_DOXYGEN_PASS 138 139 /*! 140 * \brief Narrow-char logger. Functionally equivalent to \c basic_channel_logger. 141 * 142 * See \c channel class template for a more detailed description 143 */ 144 template< typename ChannelT = std::string > 145 class channel_logger : 146 public basic_composite_logger< 147 char, 148 channel_logger< ChannelT >, 149 single_thread_model, 150 features< channel< ChannelT > > 151 > 152 { 153 public: 154 /*! 155 * Default constructor 156 */ 157 channel_logger(); 158 /*! 159 * Copy constructor 160 */ 161 channel_logger(channel_logger const& that); 162 /*! 163 * Constructor with named arguments 164 */ 165 template< typename... ArgsT > 166 explicit channel_logger(ArgsT... const& args); 167 /*! 168 * The constructor creates the logger with the specified channel name 169 * 170 * \param channel The channel name 171 */ 172 explicit channel_logger(ChannelT const& channel); 173 /*! 174 * Assignment operator 175 */ 176 channel_logger& operator= (channel_logger const& that) 177 /*! 178 * Swaps two loggers 179 */ 180 void swap(channel_logger& that); 181 }; 182 183 /*! 184 * \brief Narrow-char thread-safe logger. Functionally equivalent to \c basic_channel_logger. 185 * 186 * See \c channel class template for a more detailed description 187 */ 188 template< typename ChannelT = std::string > 189 class channel_logger_mt : 190 public basic_composite_logger< 191 char, 192 channel_logger_mt< ChannelT >, 193 multi_thread_model< implementation_defined >, 194 features< channel< ChannelT > > 195 > 196 { 197 public: 198 /*! 199 * Default constructor 200 */ 201 channel_logger_mt(); 202 /*! 203 * Copy constructor 204 */ 205 channel_logger_mt(channel_logger_mt const& that); 206 /*! 207 * Constructor with named arguments 208 */ 209 template< typename... ArgsT > 210 explicit channel_logger_mt(ArgsT... const& args); 211 /*! 212 * The constructor creates the logger with the specified channel name 213 * 214 * \param channel The channel name 215 */ 216 explicit channel_logger_mt(ChannelT const& channel); 217 /*! 218 * Assignment operator 219 */ 220 channel_logger_mt& operator= (channel_logger_mt const& that) 221 /*! 222 * Swaps two loggers 223 */ 224 void swap(channel_logger_mt& that); 225 }; 226 227 /*! 228 * \brief Wide-char logger. Functionally equivalent to \c basic_channel_logger. 229 * 230 * See \c channel class template for a more detailed description 231 */ 232 template< typename ChannelT = std::wstring > 233 class wchannel_logger : 234 public basic_composite_logger< 235 wchar_t, 236 wchannel_logger< ChannelT >, 237 single_thread_model, 238 features< channel< ChannelT > > 239 > 240 { 241 public: 242 /*! 243 * Default constructor 244 */ 245 wchannel_logger(); 246 /*! 247 * Copy constructor 248 */ 249 wchannel_logger(wchannel_logger const& that); 250 /*! 251 * Constructor with named arguments 252 */ 253 template< typename... ArgsT > 254 explicit wchannel_logger(ArgsT... const& args); 255 /*! 256 * The constructor creates the logger with the specified channel name 257 * 258 * \param channel The channel name 259 */ 260 explicit wchannel_logger(ChannelT const& channel); 261 /*! 262 * Assignment operator 263 */ 264 wchannel_logger& operator= (wchannel_logger const& that) 265 /*! 266 * Swaps two loggers 267 */ 268 void swap(wchannel_logger& that); 269 }; 270 271 /*! 272 * \brief Wide-char thread-safe logger. Functionally equivalent to \c basic_channel_logger. 273 * 274 * See \c channel class template for a more detailed description 275 */ 276 template< typename ChannelT = std::wstring > 277 class wchannel_logger_mt : 278 public basic_composite_logger< 279 wchar_t, 280 wchannel_logger< ChannelT >, 281 multi_thread_model< implementation_defined >, 282 features< channel< ChannelT > > 283 > 284 { 285 public: 286 /*! 287 * Default constructor 288 */ 289 wchannel_logger_mt(); 290 /*! 291 * Copy constructor 292 */ 293 wchannel_logger_mt(wchannel_logger_mt const& that); 294 /*! 295 * Constructor with named arguments 296 */ 297 template< typename... ArgsT > 298 explicit wchannel_logger_mt(ArgsT... const& args); 299 /*! 300 * The constructor creates the logger with the specified channel name 301 * 302 * \param channel The channel name 303 */ 304 explicit wchannel_logger_mt(ChannelT const& channel); 305 /*! 306 * Assignment operator 307 */ 308 wchannel_logger_mt& operator= (wchannel_logger_mt const& that) 309 /*! 310 * Swaps two loggers 311 */ 312 void swap(wchannel_logger_mt& that); 313 }; 314 315 #endif // BOOST_LOG_DOXYGEN_PASS 316 317 } // namespace sources 318 319 BOOST_LOG_CLOSE_NAMESPACE // namespace log 320 321 } // namespace boost 322 323 #include <boost/log/detail/footer.hpp> 324 325 #endif // BOOST_LOG_SOURCES_CHANNEL_LOGGER_HPP_INCLUDED_ 326