]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 basic_logger.hpp | |
9 | * \author Andrey Semashev | |
10 | * \date 08.03.2007 | |
11 | * | |
12 | * The header contains implementation of a base class for loggers. Convenience macros | |
13 | * for defining custom loggers are also provided. | |
14 | */ | |
15 | ||
16 | #ifndef BOOST_LOG_SOURCES_BASIC_LOGGER_HPP_INCLUDED_ | |
17 | #define BOOST_LOG_SOURCES_BASIC_LOGGER_HPP_INCLUDED_ | |
18 | ||
19 | #include <exception> | |
20 | #include <utility> | |
21 | #include <ostream> | |
22 | #include <boost/assert.hpp> | |
23 | #include <boost/move/core.hpp> | |
24 | #include <boost/move/utility_core.hpp> | |
25 | #include <boost/core/addressof.hpp> | |
26 | #include <boost/preprocessor/facilities/empty.hpp> | |
27 | #include <boost/preprocessor/facilities/identity.hpp> | |
28 | #include <boost/preprocessor/repetition/enum_params.hpp> | |
29 | #include <boost/preprocessor/repetition/enum_binary_params.hpp> | |
30 | #include <boost/preprocessor/repetition/repeat_from_to.hpp> | |
31 | #include <boost/preprocessor/seq/enum.hpp> | |
32 | #include <boost/log/detail/config.hpp> | |
33 | #include <boost/log/detail/parameter_tools.hpp> | |
34 | #include <boost/log/attributes/attribute_set.hpp> | |
35 | #include <boost/log/attributes/attribute_name.hpp> | |
36 | #include <boost/log/attributes/attribute.hpp> | |
37 | #include <boost/log/core/core.hpp> | |
38 | #include <boost/log/core/record.hpp> | |
39 | #include <boost/log/sources/features.hpp> | |
40 | #include <boost/log/sources/threading_models.hpp> | |
41 | #include <boost/log/detail/header.hpp> | |
42 | ||
43 | #ifdef BOOST_HAS_PRAGMA_ONCE | |
44 | #pragma once | |
45 | #endif | |
46 | ||
47 | namespace boost { | |
48 | ||
49 | BOOST_LOG_OPEN_NAMESPACE | |
50 | ||
51 | namespace sources { | |
52 | ||
53 | /*! | |
54 | * \brief Basic logger class | |
55 | * | |
56 | * The \c basic_logger class template serves as a base class for all loggers | |
57 | * provided by the library. It can also be used as a base for user-defined | |
58 | * loggers. The template parameters are: | |
59 | * | |
60 | * \li \c CharT - logging character type | |
61 | * \li \c FinalT - final type of the logger that eventually derives from | |
62 | * the \c basic_logger. There may be other classes in the hierarchy | |
63 | * between the final class and \c basic_logger. | |
64 | * \li \c ThreadingModelT - threading model policy. Must provide methods | |
65 | * of the Boost.Thread locking concept used in \c basic_logger class | |
66 | * and all its derivatives in the hierarchy up to the \c FinalT class. | |
67 | * The \c basic_logger class itself requires methods of the | |
68 | * SharedLockable concept. The threading model policy must also be | |
69 | * default and copy-constructible and support member function \c swap. | |
70 | * There are currently two policies provided: \c single_thread_model | |
71 | * and \c multi_thread_model. | |
72 | * | |
73 | * The logger implements fundamental facilities of loggers, such as storing | |
74 | * source-specific attribute set and formatting log record messages. The basic | |
75 | * logger interacts with the logging core in order to apply filtering and | |
76 | * pass records to sinks. | |
77 | */ | |
78 | template< typename CharT, typename FinalT, typename ThreadingModelT > | |
79 | class basic_logger : | |
80 | public ThreadingModelT | |
81 | { | |
82 | typedef basic_logger this_type; | |
83 | BOOST_COPYABLE_AND_MOVABLE_ALT(this_type) | |
84 | ||
85 | public: | |
86 | //! Character type | |
87 | typedef CharT char_type; | |
88 | //! Final logger type | |
89 | typedef FinalT final_type; | |
90 | //! Threading model type | |
91 | typedef ThreadingModelT threading_model; | |
92 | ||
93 | #if !defined(BOOST_LOG_NO_THREADS) | |
94 | //! Lock requirement for the swap_unlocked method | |
95 | typedef boost::log::aux::exclusive_lock_guard< threading_model > swap_lock; | |
96 | //! Lock requirement for the add_attribute_unlocked method | |
97 | typedef boost::log::aux::exclusive_lock_guard< threading_model > add_attribute_lock; | |
98 | //! Lock requirement for the remove_attribute_unlocked method | |
99 | typedef boost::log::aux::exclusive_lock_guard< threading_model > remove_attribute_lock; | |
100 | //! Lock requirement for the remove_all_attributes_unlocked method | |
101 | typedef boost::log::aux::exclusive_lock_guard< threading_model > remove_all_attributes_lock; | |
102 | //! Lock requirement for the get_attributes method | |
103 | typedef boost::log::aux::shared_lock_guard< const threading_model > get_attributes_lock; | |
104 | //! Lock requirement for the open_record_unlocked method | |
105 | typedef boost::log::aux::shared_lock_guard< threading_model > open_record_lock; | |
106 | //! Lock requirement for the set_attributes method | |
107 | typedef boost::log::aux::exclusive_lock_guard< threading_model > set_attributes_lock; | |
108 | #else | |
109 | typedef no_lock< threading_model > swap_lock; | |
110 | typedef no_lock< threading_model > add_attribute_lock; | |
111 | typedef no_lock< threading_model > remove_attribute_lock; | |
112 | typedef no_lock< threading_model > remove_all_attributes_lock; | |
113 | typedef no_lock< const threading_model > get_attributes_lock; | |
114 | typedef no_lock< threading_model > open_record_lock; | |
115 | typedef no_lock< threading_model > set_attributes_lock; | |
116 | #endif | |
117 | ||
118 | //! Lock requirement for the push_record_unlocked method | |
119 | typedef no_lock< threading_model > push_record_lock; | |
120 | ||
121 | private: | |
122 | //! A pointer to the logging system | |
123 | core_ptr m_pCore; | |
124 | ||
125 | //! Logger-specific attribute set | |
126 | attribute_set m_Attributes; | |
127 | ||
128 | public: | |
129 | /*! | |
130 | * Constructor. Initializes internal data structures of the basic logger class, | |
131 | * acquires reference to the logging core. | |
132 | */ | |
133 | basic_logger() : | |
134 | threading_model(), | |
135 | m_pCore(core::get()) | |
136 | { | |
137 | } | |
138 | /*! | |
139 | * Copy constructor. Copies all attributes from the source logger. | |
140 | * | |
141 | * \note Not thread-safe. The source logger must be locked in the final class before copying. | |
142 | * | |
143 | * \param that Source logger | |
144 | */ | |
145 | basic_logger(basic_logger const& that) : | |
146 | threading_model(static_cast< threading_model const& >(that)), | |
147 | m_pCore(core::get()), | |
148 | m_Attributes(that.m_Attributes) | |
149 | { | |
150 | } | |
151 | /*! | |
152 | * Move constructor. Moves all attributes from the source logger. | |
153 | * | |
154 | * \note Not thread-safe. The source logger must be locked in the final class before copying. | |
155 | * | |
156 | * \param that Source logger | |
157 | */ | |
158 | basic_logger(BOOST_RV_REF(basic_logger) that) : | |
159 | threading_model(boost::move(static_cast< threading_model& >(that))) | |
160 | { | |
161 | m_pCore.swap(that.m_pCore); | |
162 | m_Attributes.swap(that.m_Attributes); | |
163 | } | |
164 | /*! | |
165 | * Constructor with named arguments. The constructor ignores all arguments. The result of | |
166 | * construction is equivalent to default construction. | |
167 | */ | |
168 | template< typename ArgsT > | |
169 | explicit basic_logger(ArgsT const&) : | |
170 | threading_model(), | |
171 | m_pCore(core::get()) | |
172 | { | |
173 | } | |
174 | ||
175 | protected: | |
176 | /*! | |
177 | * An accessor to the logging system pointer | |
178 | */ | |
179 | core_ptr const& core() const { return m_pCore; } | |
180 | /*! | |
181 | * An accessor to the logger attributes | |
182 | */ | |
183 | attribute_set& attributes() { return m_Attributes; } | |
184 | /*! | |
185 | * An accessor to the logger attributes | |
186 | */ | |
187 | attribute_set const& attributes() const { return m_Attributes; } | |
188 | /*! | |
189 | * An accessor to the threading model base | |
190 | */ | |
191 | threading_model& get_threading_model() { return *this; } | |
192 | /*! | |
193 | * An accessor to the threading model base | |
194 | */ | |
195 | threading_model const& get_threading_model() const { return *this; } | |
196 | /*! | |
197 | * An accessor to the final logger | |
198 | */ | |
199 | final_type* final_this() | |
200 | { | |
201 | BOOST_LOG_ASSUME(this != NULL); | |
202 | return static_cast< final_type* >(this); | |
203 | } | |
204 | /*! | |
205 | * An accessor to the final logger | |
206 | */ | |
207 | final_type const* final_this() const | |
208 | { | |
209 | BOOST_LOG_ASSUME(this != NULL); | |
210 | return static_cast< final_type const* >(this); | |
211 | } | |
212 | ||
213 | /*! | |
214 | * Unlocked \c swap | |
215 | */ | |
216 | void swap_unlocked(basic_logger& that) | |
217 | { | |
218 | get_threading_model().swap(that.get_threading_model()); | |
219 | m_Attributes.swap(that.m_Attributes); | |
220 | } | |
221 | ||
222 | /*! | |
223 | * Unlocked \c add_attribute | |
224 | */ | |
225 | std::pair< attribute_set::iterator, bool > add_attribute_unlocked(attribute_name const& name, attribute const& attr) | |
226 | { | |
227 | return m_Attributes.insert(name, attr); | |
228 | } | |
229 | ||
230 | /*! | |
231 | * Unlocked \c remove_attribute | |
232 | */ | |
233 | void remove_attribute_unlocked(attribute_set::iterator it) | |
234 | { | |
235 | m_Attributes.erase(it); | |
236 | } | |
237 | ||
238 | /*! | |
239 | * Unlocked \c remove_all_attributes | |
240 | */ | |
241 | void remove_all_attributes_unlocked() | |
242 | { | |
243 | m_Attributes.clear(); | |
244 | } | |
245 | ||
246 | /*! | |
247 | * Unlocked \c open_record | |
248 | */ | |
249 | record open_record_unlocked() | |
250 | { | |
251 | return m_pCore->open_record(m_Attributes); | |
252 | } | |
253 | /*! | |
254 | * Unlocked \c open_record | |
255 | */ | |
256 | template< typename ArgsT > | |
257 | record open_record_unlocked(ArgsT const&) | |
258 | { | |
259 | return m_pCore->open_record(m_Attributes); | |
260 | } | |
261 | ||
262 | /*! | |
263 | * Unlocked \c push_record | |
264 | */ | |
265 | void push_record_unlocked(BOOST_RV_REF(record) rec) | |
266 | { | |
267 | m_pCore->push_record(boost::move(rec)); | |
268 | } | |
269 | ||
270 | /*! | |
271 | * Unlocked \c get_attributes | |
272 | */ | |
273 | attribute_set get_attributes_unlocked() const | |
274 | { | |
275 | return m_Attributes; | |
276 | } | |
277 | ||
278 | /*! | |
279 | * Unlocked \c set_attributes | |
280 | */ | |
281 | void set_attributes_unlocked(attribute_set const& attrs) | |
282 | { | |
283 | m_Attributes = attrs; | |
284 | } | |
285 | ||
286 | //! Assignment is closed (should be implemented through copy and swap in the final class) | |
287 | BOOST_DELETED_FUNCTION(basic_logger& operator= (basic_logger const&)) | |
288 | }; | |
289 | ||
290 | /*! | |
291 | * Free-standing swap for all loggers | |
292 | */ | |
293 | template< typename CharT, typename FinalT, typename ThreadingModelT > | |
294 | inline void swap( | |
295 | basic_logger< CharT, FinalT, ThreadingModelT >& left, | |
296 | basic_logger< CharT, FinalT, ThreadingModelT >& right) | |
297 | { | |
298 | static_cast< FinalT& >(left).swap(static_cast< FinalT& >(right)); | |
299 | } | |
300 | ||
301 | /*! | |
302 | * \brief A composite logger that inherits a number of features | |
303 | * | |
304 | * The composite logger is a helper class that simplifies feature composition into the final logger. | |
305 | * The user's logger class is expected to derive from the composite logger class, instantiated with | |
306 | * the character type, the user's logger class, the threading model and the list of the required features. | |
307 | * The former three parameters are passed to the \c basic_logger class template. The feature list | |
308 | * must be an MPL type sequence, where each element is a unary MPL metafunction class, that upon | |
309 | * applying on its argument results in a logging feature class that derives from the argument. | |
310 | * Every logger feature provided by the library can participate in the feature list. | |
311 | */ | |
312 | template< typename CharT, typename FinalT, typename ThreadingModelT, typename FeaturesT > | |
313 | class basic_composite_logger : | |
314 | public boost::log::sources::aux::inherit_features< | |
315 | basic_logger< CharT, FinalT, ThreadingModelT >, | |
316 | FeaturesT | |
317 | >::type | |
318 | { | |
319 | private: | |
320 | //! Base type (the hierarchy of features) | |
321 | typedef typename boost::log::sources::aux::inherit_features< | |
322 | basic_logger< CharT, FinalT, ThreadingModelT >, | |
323 | FeaturesT | |
324 | >::type base_type; | |
325 | ||
326 | protected: | |
327 | //! The composite logger type (for use in the user's logger class) | |
328 | typedef basic_composite_logger logger_base; | |
329 | BOOST_COPYABLE_AND_MOVABLE_ALT(logger_base) | |
330 | ||
331 | public: | |
332 | //! Threading model being used | |
333 | typedef typename base_type::threading_model threading_model; | |
334 | ||
335 | #if !defined(BOOST_LOG_NO_THREADS) | |
336 | ||
337 | public: | |
338 | /*! | |
339 | * Default constructor (default-constructs all features) | |
340 | */ | |
341 | basic_composite_logger() {} | |
342 | /*! | |
343 | * Copy constructor | |
344 | */ | |
345 | basic_composite_logger(basic_composite_logger const& that) : | |
346 | base_type | |
347 | (( | |
348 | boost::log::aux::shared_lock_guard< const threading_model >(that.get_threading_model()), | |
349 | static_cast< base_type const& >(that) | |
350 | )) | |
351 | { | |
352 | } | |
353 | /*! | |
354 | * Move constructor | |
355 | */ | |
356 | basic_composite_logger(BOOST_RV_REF(logger_base) that) : | |
357 | base_type(boost::move(static_cast< base_type& >(that))) | |
358 | { | |
359 | } | |
360 | /*! | |
361 | * Constructor with named parameters | |
362 | */ | |
363 | template< typename ArgsT > | |
364 | explicit basic_composite_logger(ArgsT const& args) : base_type(args) | |
365 | { | |
366 | } | |
367 | ||
368 | /*! | |
369 | * The method adds an attribute to the source-specific attribute set. The attribute will be implicitly added to | |
370 | * every log record made with the current logger. | |
371 | * | |
372 | * \param name The attribute name. | |
373 | * \param attr The attribute factory. | |
374 | * \return A pair of values. If the second member is \c true, then the attribute is added and the first member points to the | |
375 | * attribute. Otherwise the attribute was not added and the first member points to the attribute that prevents | |
376 | * addition. | |
377 | */ | |
378 | std::pair< attribute_set::iterator, bool > add_attribute(attribute_name const& name, attribute const& attr) | |
379 | { | |
380 | typename base_type::add_attribute_lock lock(base_type::get_threading_model()); | |
381 | return base_type::add_attribute_unlocked(name, attr); | |
382 | } | |
383 | /*! | |
384 | * The method removes an attribute from the source-specific attribute set. | |
385 | * | |
386 | * \pre The attribute was added with the add_attribute call for this instance of the logger. | |
387 | * \post The attribute is no longer registered as a source-specific attribute for this logger. The iterator is invalidated after removal. | |
388 | * | |
389 | * \param it Iterator to the previously added attribute. | |
390 | */ | |
391 | void remove_attribute(attribute_set::iterator it) | |
392 | { | |
393 | typename base_type::remove_attribute_lock lock(base_type::get_threading_model()); | |
394 | base_type::remove_attribute_unlocked(it); | |
395 | } | |
396 | ||
397 | /*! | |
398 | * The method removes all attributes from the logger. All iterators and references to the removed attributes are invalidated. | |
399 | */ | |
400 | void remove_all_attributes() | |
401 | { | |
402 | typename base_type::remove_all_attributes_lock lock(base_type::get_threading_model()); | |
403 | base_type::remove_all_attributes_unlocked(); | |
404 | } | |
405 | ||
406 | /*! | |
407 | * The method retrieves a copy of a set with all attributes from the logger. | |
408 | * | |
409 | * \return The copy of the attribute set. Attributes are shallow-copied. | |
410 | */ | |
411 | attribute_set get_attributes() const | |
412 | { | |
413 | typename base_type::get_attributes_lock lock(base_type::get_threading_model()); | |
414 | return base_type::get_attributes_unlocked(); | |
415 | } | |
416 | ||
417 | /*! | |
418 | * The method installs the whole attribute set into the logger. All iterators and references to elements of | |
419 | * the previous set are invalidated. Iterators to the \a attrs set are not valid to be used with the logger (that is, | |
420 | * the logger owns a copy of \a attrs after completion). | |
421 | * | |
422 | * \param attrs The set of attributes to install into the logger. Attributes are shallow-copied. | |
423 | */ | |
424 | void set_attributes(attribute_set const& attrs) | |
425 | { | |
426 | typename base_type::set_attributes_lock lock(base_type::get_threading_model()); | |
427 | base_type::set_attributes_unlocked(attrs); | |
428 | } | |
429 | ||
430 | /*! | |
431 | * The method opens a new log record in the logging core. | |
432 | * | |
433 | * \return A valid record handle if the logging record is opened successfully, an invalid handle otherwise. | |
434 | */ | |
435 | record open_record() | |
436 | { | |
437 | // Perform a quick check first | |
438 | if (this->core()->get_logging_enabled()) | |
439 | { | |
440 | typename base_type::open_record_lock lock(base_type::get_threading_model()); | |
441 | return base_type::open_record_unlocked(boost::log::aux::empty_arg_list()); | |
442 | } | |
443 | else | |
444 | return record(); | |
445 | } | |
446 | /*! | |
447 | * The method opens a new log record in the logging core. | |
448 | * | |
449 | * \param args A set of additional named arguments. The parameter is ignored. | |
450 | * \return A valid record handle if the logging record is opened successfully, an invalid handle otherwise. | |
451 | */ | |
452 | template< typename ArgsT > | |
453 | record open_record(ArgsT const& args) | |
454 | { | |
455 | // Perform a quick check first | |
456 | if (this->core()->get_logging_enabled()) | |
457 | { | |
458 | typename base_type::open_record_lock lock(base_type::get_threading_model()); | |
459 | return base_type::open_record_unlocked(args); | |
460 | } | |
461 | else | |
462 | return record(); | |
463 | } | |
464 | /*! | |
465 | * The method pushes the constructed message to the logging core | |
466 | * | |
467 | * \param rec The log record with the formatted message | |
468 | */ | |
469 | void push_record(BOOST_RV_REF(record) rec) | |
470 | { | |
471 | typename base_type::push_record_lock lock(base_type::get_threading_model()); | |
472 | base_type::push_record_unlocked(boost::move(rec)); | |
473 | } | |
474 | /*! | |
475 | * Thread-safe implementation of swap | |
476 | */ | |
477 | void swap(basic_composite_logger& that) | |
478 | { | |
479 | boost::log::aux::multiple_unique_lock2< | |
480 | threading_model, | |
481 | threading_model | |
482 | > lock(base_type::get_threading_model(), that.get_threading_model()); | |
483 | base_type::swap_unlocked(that); | |
484 | } | |
485 | ||
486 | protected: | |
487 | /*! | |
488 | * Assignment for the final class. Threadsafe, provides strong exception guarantee. | |
489 | */ | |
490 | FinalT& assign(FinalT const& that) | |
491 | { | |
492 | BOOST_LOG_ASSUME(this != NULL); | |
493 | if (static_cast< FinalT* >(this) != boost::addressof(that)) | |
494 | { | |
495 | // We'll have to explicitly create the copy in order to make sure it's unlocked when we attempt to lock *this | |
496 | FinalT tmp(that); | |
497 | boost::log::aux::exclusive_lock_guard< threading_model > lock(base_type::get_threading_model()); | |
498 | base_type::swap_unlocked(tmp); | |
499 | } | |
500 | return static_cast< FinalT& >(*this); | |
501 | } | |
502 | }; | |
503 | ||
504 | //! An optimized composite logger version with no multithreading support | |
505 | template< typename CharT, typename FinalT, typename FeaturesT > | |
506 | class basic_composite_logger< CharT, FinalT, single_thread_model, FeaturesT > : | |
507 | public boost::log::sources::aux::inherit_features< | |
508 | basic_logger< CharT, FinalT, single_thread_model >, | |
509 | FeaturesT | |
510 | >::type | |
511 | { | |
512 | private: | |
513 | typedef typename boost::log::sources::aux::inherit_features< | |
514 | basic_logger< CharT, FinalT, single_thread_model >, | |
515 | FeaturesT | |
516 | >::type base_type; | |
517 | ||
518 | protected: | |
519 | typedef basic_composite_logger logger_base; | |
520 | BOOST_COPYABLE_AND_MOVABLE_ALT(logger_base) | |
521 | ||
522 | public: | |
523 | typedef typename base_type::threading_model threading_model; | |
524 | ||
525 | #endif // !defined(BOOST_LOG_NO_THREADS) | |
526 | ||
527 | public: | |
528 | basic_composite_logger() {} | |
529 | basic_composite_logger(basic_composite_logger const& that) : | |
530 | base_type(static_cast< base_type const& >(that)) | |
531 | { | |
532 | } | |
533 | basic_composite_logger(BOOST_RV_REF(logger_base) that) : | |
534 | base_type(boost::move(static_cast< base_type& >(that))) | |
535 | { | |
536 | } | |
537 | template< typename ArgsT > | |
538 | explicit basic_composite_logger(ArgsT const& args) : base_type(args) | |
539 | { | |
540 | } | |
541 | ||
542 | std::pair< attribute_set::iterator, bool > add_attribute(attribute_name const& name, attribute const& attr) | |
543 | { | |
544 | return base_type::add_attribute_unlocked(name, attr); | |
545 | } | |
546 | void remove_attribute(attribute_set::iterator it) | |
547 | { | |
548 | base_type::remove_attribute_unlocked(it); | |
549 | } | |
550 | void remove_all_attributes() | |
551 | { | |
552 | base_type::remove_all_attributes_unlocked(); | |
553 | } | |
554 | attribute_set get_attributes() const | |
555 | { | |
556 | return base_type::get_attributes_unlocked(); | |
557 | } | |
558 | void set_attributes(attribute_set const& attrs) | |
559 | { | |
560 | base_type::set_attributes_unlocked(attrs); | |
561 | } | |
562 | record open_record() | |
563 | { | |
564 | // Perform a quick check first | |
565 | if (this->core()->get_logging_enabled()) | |
566 | return base_type::open_record_unlocked(boost::log::aux::empty_arg_list()); | |
567 | else | |
568 | return record(); | |
569 | } | |
570 | template< typename ArgsT > | |
571 | record open_record(ArgsT const& args) | |
572 | { | |
573 | // Perform a quick check first | |
574 | if (this->core()->get_logging_enabled()) | |
575 | return base_type::open_record_unlocked(args); | |
576 | else | |
577 | return record(); | |
578 | } | |
579 | void push_record(BOOST_RV_REF(record) rec) | |
580 | { | |
581 | base_type::push_record_unlocked(boost::move(rec)); | |
582 | } | |
583 | void swap(basic_composite_logger& that) | |
584 | { | |
585 | base_type::swap_unlocked(that); | |
586 | } | |
587 | ||
588 | protected: | |
589 | FinalT& assign(FinalT that) | |
590 | { | |
591 | base_type::swap_unlocked(that); | |
592 | return static_cast< FinalT& >(*this); | |
593 | } | |
594 | }; | |
595 | ||
596 | ||
597 | #ifndef BOOST_LOG_DOXYGEN_PASS | |
598 | ||
599 | #define BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS_IMPL(class_type, typename_keyword)\ | |
600 | public:\ | |
601 | BOOST_DEFAULTED_FUNCTION(class_type(), {})\ | |
602 | class_type(class_type const& that) : class_type::logger_base(\ | |
603 | static_cast< typename_keyword() class_type::logger_base const& >(that)) {}\ | |
604 | class_type(BOOST_RV_REF(class_type) that) : class_type::logger_base(\ | |
605 | ::boost::move(static_cast< typename_keyword() class_type::logger_base& >(that))) {}\ | |
606 | BOOST_LOG_PARAMETRIZED_CONSTRUCTORS_FORWARD(class_type, class_type::logger_base)\ | |
607 | ||
608 | #endif // BOOST_LOG_DOXYGEN_PASS | |
609 | ||
610 | #define BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS(class_type)\ | |
611 | BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS_IMPL(class_type, BOOST_PP_EMPTY) | |
612 | ||
613 | #define BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS_TEMPLATE(class_type)\ | |
614 | BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS_IMPL(class_type, BOOST_PP_IDENTITY(typename)) | |
615 | ||
616 | #define BOOST_LOG_FORWARD_LOGGER_ASSIGNMENT(class_type)\ | |
617 | public:\ | |
618 | class_type& operator= (BOOST_COPY_ASSIGN_REF(class_type) that)\ | |
619 | {\ | |
620 | return class_type::logger_base::assign(static_cast< class_type const& >(that));\ | |
621 | }\ | |
622 | class_type& operator= (BOOST_RV_REF(class_type) that)\ | |
623 | {\ | |
624 | BOOST_LOG_EXPR_IF_MT(::boost::log::aux::exclusive_lock_guard< class_type::threading_model > lock(this->get_threading_model());)\ | |
625 | this->swap_unlocked(that);\ | |
626 | return *this;\ | |
627 | } | |
628 | ||
629 | #define BOOST_LOG_FORWARD_LOGGER_ASSIGNMENT_TEMPLATE(class_type)\ | |
630 | public:\ | |
631 | class_type& operator= (BOOST_COPY_ASSIGN_REF(class_type) that)\ | |
632 | {\ | |
633 | return class_type::logger_base::assign(static_cast< class_type const& >(that));\ | |
634 | }\ | |
635 | class_type& operator= (BOOST_RV_REF(class_type) that)\ | |
636 | {\ | |
637 | BOOST_LOG_EXPR_IF_MT(::boost::log::aux::exclusive_lock_guard< typename class_type::threading_model > lock(this->get_threading_model());)\ | |
638 | this->swap_unlocked(that);\ | |
639 | return *this;\ | |
640 | } | |
641 | ||
642 | #define BOOST_LOG_FORWARD_LOGGER_MEMBERS(class_type)\ | |
643 | BOOST_COPYABLE_AND_MOVABLE(class_type)\ | |
644 | BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS(class_type)\ | |
645 | BOOST_LOG_FORWARD_LOGGER_ASSIGNMENT(class_type) | |
646 | ||
647 | #define BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(class_type)\ | |
648 | BOOST_COPYABLE_AND_MOVABLE(class_type)\ | |
649 | BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS_TEMPLATE(class_type)\ | |
650 | BOOST_LOG_FORWARD_LOGGER_ASSIGNMENT_TEMPLATE(class_type) | |
651 | ||
652 | } // namespace sources | |
653 | ||
654 | BOOST_LOG_CLOSE_NAMESPACE // namespace log | |
655 | ||
656 | } // namespace boost | |
657 | ||
658 | /*! | |
659 | * \brief The macro declares a logger class that inherits a number of base classes | |
660 | * | |
661 | * \param type_name The name of the logger class to declare | |
662 | * \param char_type The character type of the logger. Either char or wchar_t expected. | |
663 | * \param base_seq A Boost.Preprocessor sequence of type identifiers of the base classes templates | |
664 | * \param threading A threading model class | |
665 | */ | |
666 | #define BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, char_type, base_seq, threading)\ | |
667 | class type_name :\ | |
668 | public ::boost::log::sources::basic_composite_logger<\ | |
669 | char_type,\ | |
670 | type_name,\ | |
671 | threading,\ | |
672 | ::boost::log::sources::features< BOOST_PP_SEQ_ENUM(base_seq) >\ | |
673 | >\ | |
674 | {\ | |
675 | BOOST_LOG_FORWARD_LOGGER_MEMBERS(type_name)\ | |
676 | } | |
677 | ||
678 | ||
679 | ||
680 | #ifdef BOOST_LOG_USE_CHAR | |
681 | ||
682 | /*! | |
683 | * \brief The macro declares a narrow-char logger class that inherits a number of base classes | |
684 | * | |
685 | * Equivalent to BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, char, base_seq, single_thread_model) | |
686 | * | |
687 | * \param type_name The name of the logger class to declare | |
688 | * \param base_seq A Boost.Preprocessor sequence of type identifiers of the base classes templates | |
689 | */ | |
690 | #define BOOST_LOG_DECLARE_LOGGER(type_name, base_seq)\ | |
691 | BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, char, base_seq, ::boost::log::sources::single_thread_model) | |
692 | ||
693 | #if !defined(BOOST_LOG_NO_THREADS) | |
694 | ||
695 | /*! | |
696 | * \brief The macro declares a narrow-char thread-safe logger class that inherits a number of base classes | |
697 | * | |
698 | * Equivalent to <tt>BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, char, base_seq, multi_thread_model< shared_mutex >)</tt> | |
699 | * | |
700 | * \param type_name The name of the logger class to declare | |
701 | * \param base_seq A Boost.Preprocessor sequence of type identifiers of the base classes templates | |
702 | */ | |
703 | #define BOOST_LOG_DECLARE_LOGGER_MT(type_name, base_seq)\ | |
704 | BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, char, base_seq,\ | |
705 | ::boost::log::sources::multi_thread_model< ::boost::shared_mutex >) | |
706 | ||
707 | #endif // !defined(BOOST_LOG_NO_THREADS) | |
708 | #endif // BOOST_LOG_USE_CHAR | |
709 | ||
710 | #ifdef BOOST_LOG_USE_WCHAR_T | |
711 | ||
712 | /*! | |
713 | * \brief The macro declares a wide-char logger class that inherits a number of base classes | |
714 | * | |
715 | * Equivalent to BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, wchar_t, base_seq, single_thread_model) | |
716 | * | |
717 | * \param type_name The name of the logger class to declare | |
718 | * \param base_seq A Boost.Preprocessor sequence of type identifiers of the base classes templates | |
719 | */ | |
720 | #define BOOST_LOG_DECLARE_WLOGGER(type_name, base_seq)\ | |
721 | BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, wchar_t, base_seq, ::boost::log::sources::single_thread_model) | |
722 | ||
723 | #if !defined(BOOST_LOG_NO_THREADS) | |
724 | ||
725 | /*! | |
726 | * \brief The macro declares a wide-char thread-safe logger class that inherits a number of base classes | |
727 | * | |
728 | * Equivalent to <tt>BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, wchar_t, base_seq, multi_thread_model< shared_mutex >)</tt> | |
729 | * | |
730 | * \param type_name The name of the logger class to declare | |
731 | * \param base_seq A Boost.Preprocessor sequence of type identifiers of the base classes templates | |
732 | */ | |
733 | #define BOOST_LOG_DECLARE_WLOGGER_MT(type_name, base_seq)\ | |
734 | BOOST_LOG_DECLARE_LOGGER_TYPE(type_name, wchar_t, base_seq,\ | |
735 | ::boost::log::sources::multi_thread_model< ::boost::shared_mutex >) | |
736 | ||
737 | #endif // !defined(BOOST_LOG_NO_THREADS) | |
738 | #endif // BOOST_LOG_USE_WCHAR_T | |
739 | ||
740 | #include <boost/log/detail/footer.hpp> | |
741 | ||
742 | #endif // BOOST_LOG_SOURCES_BASIC_LOGGER_HPP_INCLUDED_ |