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 value_extraction.hpp
9 * \author Andrey Semashev
10 * \date 01.03.2008
11 *
12 * The header contains implementation of tools for extracting an attribute value
13 * from the view.
14 */
15
16 #ifndef BOOST_LOG_ATTRIBUTES_VALUE_EXTRACTION_HPP_INCLUDED_
17 #define BOOST_LOG_ATTRIBUTES_VALUE_EXTRACTION_HPP_INCLUDED_
18
19 #include <boost/mpl/vector.hpp>
20 #include <boost/mpl/joint_view.hpp>
21 #include <boost/mpl/if.hpp>
22 #include <boost/mpl/eval_if.hpp>
23 #include <boost/mpl/identity.hpp>
24 #include <boost/mpl/is_sequence.hpp>
25 #include <boost/mpl/contains.hpp>
26 #include <boost/mpl/push_back.hpp>
27 #include <boost/type_traits/is_same.hpp>
28 #include <boost/core/enable_if.hpp>
29 #include <boost/log/detail/config.hpp>
30 #include <boost/log/exceptions.hpp>
31 #include <boost/log/core/record.hpp>
32 #include <boost/log/attributes/attribute_name.hpp>
33 #include <boost/log/attributes/attribute_value.hpp>
34 #include <boost/log/attributes/attribute.hpp>
35 #include <boost/log/attributes/attribute_value_set.hpp>
36 #include <boost/log/attributes/value_extraction_fwd.hpp>
37 #include <boost/log/attributes/fallback_policy.hpp>
38 #include <boost/log/expressions/keyword_fwd.hpp>
39 #include <boost/log/utility/value_ref.hpp>
40 #include <boost/log/utility/type_dispatch/static_type_dispatcher.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 result_of {
52
53 /*!
54 * \brief A metafunction that allows to acquire the result of the value extraction
55 *
56 * The metafunction results in a type that is in form of <tt>T const&</tt>, if \c T is
57 * not an MPL type sequence and <tt>DefaultT</tt> is the same as <tt>T</tt>,
58 * or <tt>value_ref< TypesT, TagT ></tt> otherwise, with
59 * \c TypesT being a type sequence comprising the types from sequence \c T and \c DefaultT,
60 * if it is not present in \c T already.
61 */
62 template< typename T, typename DefaultT, typename TagT >
63 struct extract_or_default
64 {
65 typedef typename mpl::eval_if<
66 mpl::is_sequence< T >,
67 mpl::eval_if<
68 mpl::contains< T, DefaultT >,
69 mpl::identity< T >,
70 mpl::push_back< T, DefaultT >
71 >,
72 mpl::if_<
73 is_same< T, DefaultT >,
74 T,
75 mpl::vector2< T, DefaultT >
76 >
77 >::type extracted_type;
78
79 typedef typename mpl::if_<
80 mpl::is_sequence< extracted_type >,
81 value_ref< extracted_type, TagT >,
82 extracted_type const&
83 >::type type;
84 };
85
86 /*!
87 * \brief A metafunction that allows to acquire the result of the value extraction
88 *
89 * The metafunction results in a type that is in form of <tt>T const&</tt>, if \c T is
90 * not an MPL type sequence, or <tt>value_ref< T, TagT ></tt> otherwise. In the latter
91 * case the value reference shall never be empty.
92 */
93 template< typename T, typename TagT >
94 struct extract_or_throw
95 {
96 typedef typename mpl::if_<
97 mpl::is_sequence< T >,
98 value_ref< T, TagT >,
99 T const&
100 >::type type;
101 };
102
103 /*!
104 * \brief A metafunction that allows to acquire the result of the value extraction
105 *
106 * The metafunction results in a type that is in form of <tt>value_ref< T, TagT ></tt>.
107 */
108 template< typename T, typename TagT >
109 struct extract
110 {
111 typedef value_ref< T, TagT > type;
112 };
113
114 } // namespace result_of
115
116 namespace aux {
117
118 //! The function object initializes the value reference
119 template< typename RefT >
120 struct value_ref_initializer
121 {
122 typedef void result_type;
123
value_ref_initializerboost::aux::value_ref_initializer124 value_ref_initializer(RefT& ref) : m_ref(ref)
125 {
126 }
127
128 template< typename ArgT >
operator ()boost::aux::value_ref_initializer129 result_type operator() (ArgT const& arg) const
130 {
131 m_ref = RefT(arg);
132 }
133
134 private:
135 RefT& m_ref;
136 };
137
138 //! The function unwraps \c value_ref, if possible
139 template< typename T, typename TagT >
140 BOOST_FORCEINLINE typename boost::enable_if_c< mpl::is_sequence< T >::value, value_ref< T, TagT > >::type
unwrap_value_ref(value_ref<T,TagT> const & r)141 unwrap_value_ref(value_ref< T, TagT > const& r)
142 {
143 return r;
144 }
145
146 template< typename T, typename TagT >
147 BOOST_FORCEINLINE typename boost::disable_if_c< mpl::is_sequence< T >::value, T const& >::type
unwrap_value_ref(value_ref<T,TagT> const & r)148 unwrap_value_ref(value_ref< T, TagT > const& r)
149 {
150 return r.get();
151 }
152
153 } // namespace aux
154
155 /*!
156 * \brief Generic attribute value extractor
157 *
158 * Attribute value extractor is a functional object that attempts to find and extract the stored
159 * attribute value from the attribute values view or a log record. The extracted value is returned
160 * from the extractor.
161 */
162 template< typename T, typename FallbackPolicyT, typename TagT >
163 class value_extractor :
164 private FallbackPolicyT
165 {
166 public:
167 //! Fallback policy
168 typedef FallbackPolicyT fallback_policy;
169 //! Attribute value types
170 typedef T value_type;
171 //! Function object result type
172 typedef value_ref< value_type, TagT > result_type;
173
174 public:
175 /*!
176 * Default constructor
177 */
value_extractor()178 BOOST_DEFAULTED_FUNCTION(value_extractor(), {})
179
180 /*!
181 * Copy constructor
182 */
183 value_extractor(value_extractor const& that) : fallback_policy(static_cast< fallback_policy const& >(that))
184 {
185 }
186
187 /*!
188 * Constructor
189 *
190 * \param arg Fallback policy constructor argument
191 */
192 template< typename U >
value_extractor(U const & arg)193 explicit value_extractor(U const& arg) : fallback_policy(arg) {}
194
195 /*!
196 * Extraction operator. Attempts to acquire the stored value of one of the supported types. If extraction succeeds,
197 * the extracted value is returned.
198 *
199 * \param attr The attribute value to extract from.
200 * \return The extracted value, if extraction succeeded, an empty value otherwise.
201 */
operator ()(attribute_value const & attr) const202 result_type operator() (attribute_value const& attr) const
203 {
204 result_type res;
205 aux::value_ref_initializer< result_type > initializer(res);
206 if (!!attr)
207 {
208 static_type_dispatcher< value_type > disp(initializer);
209 if (!attr.dispatch(disp) && !fallback_policy::apply_default(initializer))
210 fallback_policy::on_invalid_type(attr.get_type());
211 }
212 else if (!fallback_policy::apply_default(initializer))
213 {
214 fallback_policy::on_missing_value();
215 }
216 return res;
217 }
218
219 /*!
220 * Extraction operator. Looks for an attribute value with the specified name
221 * and tries to acquire the stored value of one of the supported types. If extraction succeeds,
222 * the extracted value is returned.
223 *
224 * \param name Attribute value name.
225 * \param attrs A set of attribute values in which to look for the specified attribute value.
226 * \return The extracted value, if extraction succeeded, an empty value otherwise.
227 */
operator ()(attribute_name const & name,attribute_value_set const & attrs) const228 result_type operator() (attribute_name const& name, attribute_value_set const& attrs) const
229 {
230 try
231 {
232 attribute_value_set::const_iterator it = attrs.find(name);
233 if (it != attrs.end())
234 return operator() (it->second);
235 else
236 return operator() (attribute_value());
237 }
238 catch (exception& e)
239 {
240 // Attach the attribute name to the exception
241 boost::log::aux::attach_attribute_name_info(e, name);
242 throw;
243 }
244 }
245
246 /*!
247 * Extraction operator. Looks for an attribute value with the specified name
248 * and tries to acquire the stored value of one of the supported types. If extraction succeeds,
249 * the extracted value is returned.
250 *
251 * \param name Attribute value name.
252 * \param rec A log record. The attribute value will be sought among those associated with the record.
253 * \return The extracted value, if extraction succeeded, an empty value otherwise.
254 */
operator ()(attribute_name const & name,record const & rec) const255 result_type operator() (attribute_name const& name, record const& rec) const
256 {
257 return operator() (name, rec.attribute_values());
258 }
259
260 /*!
261 * Extraction operator. Looks for an attribute value with the specified name
262 * and tries to acquire the stored value of one of the supported types. If extraction succeeds,
263 * the extracted value is returned.
264 *
265 * \param name Attribute value name.
266 * \param rec A log record view. The attribute value will be sought among those associated with the record.
267 * \return The extracted value, if extraction succeeded, an empty value otherwise.
268 */
operator ()(attribute_name const & name,record_view const & rec) const269 result_type operator() (attribute_name const& name, record_view const& rec) const
270 {
271 return operator() (name, rec.attribute_values());
272 }
273
274 /*!
275 * \returns Fallback policy
276 */
get_fallback_policy() const277 fallback_policy const& get_fallback_policy() const
278 {
279 return *static_cast< fallback_policy const* >(this);
280 }
281 };
282
283 #if !defined(BOOST_LOG_DOXYGEN_PASS)
284 #if !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
285 #define BOOST_LOG_AUX_VOID_DEFAULT = void
286 #else
287 #define BOOST_LOG_AUX_VOID_DEFAULT
288 #endif
289 #endif // !defined(BOOST_LOG_DOXYGEN_PASS)
290
291 /*!
292 * The function extracts an attribute value from the view. The user has to explicitly specify the
293 * type or set of possible types of the attribute value to be extracted.
294 *
295 * \param name The name of the attribute value to extract.
296 * \param attrs A set of attribute values in which to look for the specified attribute value.
297 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
298 */
299 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract(attribute_name const & name,attribute_value_set const & attrs)300 inline typename result_of::extract< T, TagT >::type extract(attribute_name const& name, attribute_value_set const& attrs)
301 {
302 value_extractor< T, fallback_to_none, TagT > extractor;
303 return extractor(name, attrs);
304 }
305
306 /*!
307 * The function extracts an attribute value from the view. The user has to explicitly specify the
308 * type or set of possible types of the attribute value to be extracted.
309 *
310 * \param name The name of the attribute value to extract.
311 * \param rec A log record. The attribute value will be sought among those associated with the record.
312 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
313 */
314 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract(attribute_name const & name,record const & rec)315 inline typename result_of::extract< T, TagT >::type extract(attribute_name const& name, record const& rec)
316 {
317 value_extractor< T, fallback_to_none, TagT > extractor;
318 return extractor(name, rec);
319 }
320
321 /*!
322 * The function extracts an attribute value from the view. The user has to explicitly specify the
323 * type or set of possible types of the attribute value to be extracted.
324 *
325 * \param name The name of the attribute value to extract.
326 * \param rec A log record view. The attribute value will be sought among those associated with the record.
327 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
328 */
329 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract(attribute_name const & name,record_view const & rec)330 inline typename result_of::extract< T, TagT >::type extract(attribute_name const& name, record_view const& rec)
331 {
332 value_extractor< T, fallback_to_none, TagT > extractor;
333 return extractor(name, rec);
334 }
335
336 /*!
337 * The function extracts an attribute value from the view. The user has to explicitly specify the
338 * type or set of possible types of the attribute value to be extracted.
339 *
340 * \param value Attribute value.
341 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
342 */
343 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract(attribute_value const & value)344 inline typename result_of::extract< T, TagT >::type extract(attribute_value const& value)
345 {
346 value_extractor< T, fallback_to_none, TagT > extractor;
347 return extractor(value);
348 }
349
350 /*!
351 * The function extracts an attribute value from the view. The user has to explicitly specify the
352 * type or set of possible types of the attribute value to be extracted.
353 *
354 * \param name The name of the attribute value to extract.
355 * \param attrs A set of attribute values in which to look for the specified attribute value.
356 * \return The extracted value or a non-empty \c value_ref that refers to the value.
357 * \throws An exception is thrown if the requested value cannot be extracted.
358 */
359 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract_or_throw(attribute_name const & name,attribute_value_set const & attrs)360 inline typename result_of::extract_or_throw< T, TagT >::type extract_or_throw(attribute_name const& name, attribute_value_set const& attrs)
361 {
362 value_extractor< T, fallback_to_throw, TagT > extractor;
363 return aux::unwrap_value_ref(extractor(name, attrs));
364 }
365
366 /*!
367 * The function extracts an attribute value from the view. The user has to explicitly specify the
368 * type or set of possible types of the attribute value to be extracted.
369 *
370 * \param name The name of the attribute value to extract.
371 * \param rec A log record. The attribute value will be sought among those associated with the record.
372 * \return The extracted value or a non-empty \c value_ref that refers to the value.
373 * \throws An exception is thrown if the requested value cannot be extracted.
374 */
375 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract_or_throw(attribute_name const & name,record const & rec)376 inline typename result_of::extract_or_throw< T, TagT >::type extract_or_throw(attribute_name const& name, record const& rec)
377 {
378 value_extractor< T, fallback_to_throw, TagT > extractor;
379 return aux::unwrap_value_ref(extractor(name, rec));
380 }
381
382 /*!
383 * The function extracts an attribute value from the view. The user has to explicitly specify the
384 * type or set of possible types of the attribute value to be extracted.
385 *
386 * \param name The name of the attribute value to extract.
387 * \param rec A log record view. The attribute value will be sought among those associated with the record.
388 * \return The extracted value or a non-empty \c value_ref that refers to the value.
389 * \throws An exception is thrown if the requested value cannot be extracted.
390 */
391 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract_or_throw(attribute_name const & name,record_view const & rec)392 inline typename result_of::extract_or_throw< T, TagT >::type extract_or_throw(attribute_name const& name, record_view const& rec)
393 {
394 value_extractor< T, fallback_to_throw, TagT > extractor;
395 return aux::unwrap_value_ref(extractor(name, rec));
396 }
397
398 /*!
399 * The function extracts an attribute value from the view. The user has to explicitly specify the
400 * type or set of possible types of the attribute value to be extracted.
401 *
402 * \param value Attribute value.
403 * \return The extracted value or a non-empty \c value_ref that refers to the value.
404 * \throws An exception is thrown if the requested value cannot be extracted.
405 */
406 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT >
extract_or_throw(attribute_value const & value)407 inline typename result_of::extract_or_throw< T, TagT >::type extract_or_throw(attribute_value const& value)
408 {
409 value_extractor< T, fallback_to_throw, TagT > extractor;
410 return aux::unwrap_value_ref(extractor(value));
411 }
412
413 /*!
414 * The function extracts an attribute value from the view. The user has to explicitly specify the
415 * type or set of possible types of the attribute value to be extracted.
416 *
417 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
418 * a reference, if the temporary object is destroyed, the reference may become dangling.
419 *
420 * \param name The name of the attribute value to extract.
421 * \param attrs A set of attribute values in which to look for the specified attribute value.
422 * \param def_val The default value
423 * \return The extracted value, if found. The default value otherwise.
424 */
425 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT, typename DefaultT >
426 inline typename result_of::extract_or_default< T, DefaultT, TagT >::type
extract_or_default(attribute_name const & name,attribute_value_set const & attrs,DefaultT const & def_val)427 extract_or_default(attribute_name const& name, attribute_value_set const& attrs, DefaultT const& def_val)
428 {
429 typedef typename result_of::extract_or_default< T, DefaultT, TagT >::extracted_type extracted_type;
430 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > extractor(def_val);
431 return aux::unwrap_value_ref(extractor(name, attrs));
432 }
433
434 /*!
435 * The function extracts an attribute value from the view. The user has to explicitly specify the
436 * type or set of possible types of the attribute value to be visited.
437 *
438 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
439 * a reference, if the temporary object is destroyed, the reference may become dangling.
440 *
441 * \param name The name of the attribute value to extract.
442 * \param rec A log record. The attribute value will be sought among those associated with the record.
443 * \param def_val The default value
444 * \return The extracted value, if found. The default value otherwise.
445 */
446 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT, typename DefaultT >
447 inline typename result_of::extract_or_default< T, DefaultT, TagT >::type
extract_or_default(attribute_name const & name,record const & rec,DefaultT const & def_val)448 extract_or_default(attribute_name const& name, record const& rec, DefaultT const& def_val)
449 {
450 typedef typename result_of::extract_or_default< T, DefaultT, TagT >::extracted_type extracted_type;
451 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > extractor(def_val);
452 return aux::unwrap_value_ref(extractor(name, rec));
453 }
454
455 /*!
456 * The function extracts an attribute value from the view. The user has to explicitly specify the
457 * type or set of possible types of the attribute value to be visited.
458 *
459 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
460 * a reference, if the temporary object is destroyed, the reference may become dangling.
461 *
462 * \param name The name of the attribute value to extract.
463 * \param rec A log record view. The attribute value will be sought among those associated with the record.
464 * \param def_val The default value
465 * \return The extracted value, if found. The default value otherwise.
466 */
467 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT, typename DefaultT >
468 inline typename result_of::extract_or_default< T, DefaultT, TagT >::type
extract_or_default(attribute_name const & name,record_view const & rec,DefaultT const & def_val)469 extract_or_default(attribute_name const& name, record_view const& rec, DefaultT const& def_val)
470 {
471 typedef typename result_of::extract_or_default< T, DefaultT, TagT >::extracted_type extracted_type;
472 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > extractor(def_val);
473 return aux::unwrap_value_ref(extractor(name, rec));
474 }
475
476 /*!
477 * The function extracts an attribute value from the view. The user has to explicitly specify the
478 * type or set of possible types of the attribute value to be visited.
479 *
480 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
481 * a reference, if the temporary object is destroyed, the reference may become dangling.
482 *
483 * \param value Attribute value.
484 * \param def_val The default value
485 * \return The extracted value, if found. The default value otherwise.
486 */
487 template< typename T, typename TagT BOOST_LOG_AUX_VOID_DEFAULT, typename DefaultT >
extract_or_default(attribute_value const & value,DefaultT const & def_val)488 inline typename result_of::extract_or_default< T, DefaultT, TagT >::type extract_or_default(attribute_value const& value, DefaultT const& def_val)
489 {
490 typedef typename result_of::extract_or_default< T, DefaultT, TagT >::extracted_type extracted_type;
491 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > extractor(def_val);
492 return aux::unwrap_value_ref(extractor(value));
493 }
494
495 #if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
496
497 template< typename T >
extract(attribute_name const & name,attribute_value_set const & attrs)498 inline typename result_of::extract< T >::type extract(attribute_name const& name, attribute_value_set const& attrs)
499 {
500 value_extractor< T, fallback_to_none > extractor;
501 return extractor(name, attrs);
502 }
503
504 template< typename T >
extract(attribute_name const & name,record const & rec)505 inline typename result_of::extract< T >::type extract(attribute_name const& name, record const& rec)
506 {
507 value_extractor< T, fallback_to_none > extractor;
508 return extractor(name, rec);
509 }
510
511 template< typename T >
extract(attribute_name const & name,record_view const & rec)512 inline typename result_of::extract< T >::type extract(attribute_name const& name, record_view const& rec)
513 {
514 value_extractor< T, fallback_to_none > extractor;
515 return extractor(name, rec);
516 }
517
518 template< typename T >
extract(attribute_value const & value)519 inline typename result_of::extract< T >::type extract(attribute_value const& value)
520 {
521 value_extractor< T, fallback_to_none > extractor;
522 return extractor(value);
523 }
524
525 template< typename T >
extract_or_throw(attribute_name const & name,attribute_value_set const & attrs)526 inline typename result_of::extract_or_throw< T >::type extract_or_throw(attribute_name const& name, attribute_value_set const& attrs)
527 {
528 value_extractor< T, fallback_to_throw > extractor;
529 return aux::unwrap_value_ref(extractor(name, attrs));
530 }
531
532 template< typename T >
extract_or_throw(attribute_name const & name,record const & rec)533 inline typename result_of::extract_or_throw< T >::type extract_or_throw(attribute_name const& name, record const& rec)
534 {
535 value_extractor< T, fallback_to_throw > extractor;
536 return aux::unwrap_value_ref(extractor(name, rec));
537 }
538
539 template< typename T >
extract_or_throw(attribute_name const & name,record_view const & rec)540 inline typename result_of::extract_or_throw< T >::type extract_or_throw(attribute_name const& name, record_view const& rec)
541 {
542 value_extractor< T, fallback_to_throw > extractor;
543 return aux::unwrap_value_ref(extractor(name, rec));
544 }
545
546 template< typename T >
extract_or_throw(attribute_value const & value)547 inline typename result_of::extract_or_throw< T >::type extract_or_throw(attribute_value const& value)
548 {
549 value_extractor< T, fallback_to_throw > extractor;
550 return aux::unwrap_value_ref(extractor(value));
551 }
552
553 template< typename T, typename DefaultT >
extract_or_default(attribute_name const & name,attribute_value_set const & attrs,DefaultT const & def_val)554 inline typename result_of::extract_or_default< T, DefaultT >::type extract_or_default(
555 attribute_name const& name, attribute_value_set const& attrs, DefaultT const& def_val)
556 {
557 typedef typename result_of::extract_or_default< T, DefaultT >::extracted_type extracted_type;
558 value_extractor< extracted_type, fallback_to_default< DefaultT const& > > extractor(def_val);
559 return aux::unwrap_value_ref(extractor(name, attrs));
560 }
561
562 template< typename T, typename DefaultT >
extract_or_default(attribute_name const & name,record const & rec,DefaultT const & def_val)563 inline typename result_of::extract_or_default< T, DefaultT >::type extract_or_default(
564 attribute_name const& name, record const& rec, DefaultT const& def_val)
565 {
566 typedef typename result_of::extract_or_default< T, DefaultT >::extracted_type extracted_type;
567 value_extractor< extracted_type, fallback_to_default< DefaultT const& > > extractor(def_val);
568 return aux::unwrap_value_ref(extractor(name, rec));
569 }
570
571 template< typename T, typename DefaultT >
extract_or_default(attribute_name const & name,record_view const & rec,DefaultT const & def_val)572 inline typename result_of::extract_or_default< T, DefaultT >::type extract_or_default(
573 attribute_name const& name, record_view const& rec, DefaultT const& def_val)
574 {
575 typedef typename result_of::extract_or_default< T, DefaultT >::extracted_type extracted_type;
576 value_extractor< extracted_type, fallback_to_default< DefaultT const& > > extractor(def_val);
577 return aux::unwrap_value_ref(extractor(name, rec));
578 }
579
580 template< typename T, typename DefaultT >
extract_or_default(attribute_value const & value,DefaultT const & def_val)581 inline typename result_of::extract_or_default< T, DefaultT >::type extract_or_default(attribute_value const& value, DefaultT const& def_val)
582 {
583 typedef typename result_of::extract_or_default< T, DefaultT >::extracted_type extracted_type;
584 value_extractor< extracted_type, fallback_to_default< DefaultT const& > > extractor(def_val);
585 return aux::unwrap_value_ref(extractor(value));
586 }
587
588 #endif // defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
589
590 /*!
591 * The function extracts an attribute value from the view. The user has to explicitly specify the
592 * type or set of possible types of the attribute value to be extracted.
593 *
594 * \param keyword The keyword of the attribute value to extract.
595 * \param attrs A set of attribute values in which to look for the specified attribute value.
596 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
597 */
598 template< typename DescriptorT, template< typename > class ActorT >
599 inline typename result_of::extract< typename DescriptorT::value_type, DescriptorT >::type
extract(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,attribute_value_set const & attrs)600 extract(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, attribute_value_set const& attrs)
601 {
602 value_extractor< typename DescriptorT::value_type, fallback_to_none, DescriptorT > extractor;
603 return extractor(keyword.get_name(), attrs);
604 }
605
606 /*!
607 * The function extracts an attribute value from the view. The user has to explicitly specify the
608 * type or set of possible types of the attribute value to be extracted.
609 *
610 * \param keyword The keyword of the attribute value to extract.
611 * \param rec A log record. The attribute value will be sought among those associated with the record.
612 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
613 */
614 template< typename DescriptorT, template< typename > class ActorT >
615 inline typename result_of::extract< typename DescriptorT::value_type, DescriptorT >::type
extract(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,record const & rec)616 extract(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record const& rec)
617 {
618 value_extractor< typename DescriptorT::value_type, fallback_to_none, DescriptorT > extractor;
619 return extractor(keyword.get_name(), rec);
620 }
621
622 /*!
623 * The function extracts an attribute value from the view. The user has to explicitly specify the
624 * type or set of possible types of the attribute value to be extracted.
625 *
626 * \param keyword The keyword of the attribute value to extract.
627 * \param rec A log record view. The attribute value will be sought among those associated with the record.
628 * \return A \c value_ref that refers to the extracted value, if found. An empty value otherwise.
629 */
630 template< typename DescriptorT, template< typename > class ActorT >
631 inline typename result_of::extract< typename DescriptorT::value_type, DescriptorT >::type
extract(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,record_view const & rec)632 extract(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record_view const& rec)
633 {
634 value_extractor< typename DescriptorT::value_type, fallback_to_none, DescriptorT > extractor;
635 return extractor(keyword.get_name(), rec);
636 }
637
638 /*!
639 * The function extracts an attribute value from the view. The user has to explicitly specify the
640 * type or set of possible types of the attribute value to be extracted.
641 *
642 * \param keyword The keyword of the attribute value to extract.
643 * \param attrs A set of attribute values in which to look for the specified attribute value.
644 * \return The extracted value or a non-empty \c value_ref that refers to the value.
645 * \throws An exception is thrown if the requested value cannot be extracted.
646 */
647 template< typename DescriptorT, template< typename > class ActorT >
648 inline typename result_of::extract_or_throw< typename DescriptorT::value_type, DescriptorT >::type
extract_or_throw(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,attribute_value_set const & attrs)649 extract_or_throw(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, attribute_value_set const& attrs)
650 {
651 value_extractor< typename DescriptorT::value_type, fallback_to_throw, DescriptorT > extractor;
652 return aux::unwrap_value_ref(extractor(keyword.get_name(), attrs));
653 }
654
655 /*!
656 * The function extracts an attribute value from the view. The user has to explicitly specify the
657 * type or set of possible types of the attribute value to be extracted.
658 *
659 * \param keyword The keyword of the attribute value to extract.
660 * \param rec A log record. The attribute value will be sought among those associated with the record.
661 * \return The extracted value or a non-empty \c value_ref that refers to the value.
662 * \throws An exception is thrown if the requested value cannot be extracted.
663 */
664 template< typename DescriptorT, template< typename > class ActorT >
665 inline typename result_of::extract_or_throw< typename DescriptorT::value_type, DescriptorT >::type
extract_or_throw(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,record const & rec)666 extract_or_throw(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record const& rec)
667 {
668 value_extractor< typename DescriptorT::value_type, fallback_to_throw, DescriptorT > extractor;
669 return aux::unwrap_value_ref(extractor(keyword.get_name(), rec));
670 }
671
672 /*!
673 * The function extracts an attribute value from the view. The user has to explicitly specify the
674 * type or set of possible types of the attribute value to be extracted.
675 *
676 * \param keyword The keyword of the attribute value to extract.
677 * \param rec A log record view. The attribute value will be sought among those associated with the record.
678 * \return The extracted value or a non-empty \c value_ref that refers to the value.
679 * \throws An exception is thrown if the requested value cannot be extracted.
680 */
681 template< typename DescriptorT, template< typename > class ActorT >
682 inline typename result_of::extract_or_throw< typename DescriptorT::value_type, DescriptorT >::type
extract_or_throw(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,record_view const & rec)683 extract_or_throw(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record_view const& rec)
684 {
685 value_extractor< typename DescriptorT::value_type, fallback_to_throw, DescriptorT > extractor;
686 return aux::unwrap_value_ref(extractor(keyword.get_name(), rec));
687 }
688
689 /*!
690 * The function extracts an attribute value from the view. The user has to explicitly specify the
691 * type or set of possible types of the attribute value to be extracted.
692 *
693 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
694 * a reference, if the temporary object is destroyed, the reference may become dangling.
695 *
696 * \param keyword The keyword of the attribute value to extract.
697 * \param attrs A set of attribute values in which to look for the specified attribute value.
698 * \param def_val The default value
699 * \return The extracted value, if found. The default value otherwise.
700 */
701 template< typename DescriptorT, template< typename > class ActorT, typename DefaultT >
702 inline typename result_of::extract_or_default< typename DescriptorT::value_type, DefaultT, DescriptorT >::type
extract_or_default(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,attribute_value_set const & attrs,DefaultT const & def_val)703 extract_or_default(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, attribute_value_set const& attrs, DefaultT const& def_val)
704 {
705 typedef typename result_of::extract_or_default< typename DescriptorT::value_type, DefaultT, DescriptorT >::extracted_type extracted_type;
706 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, DescriptorT > extractor(def_val);
707 return aux::unwrap_value_ref(extractor(keyword.get_name(), attrs));
708 }
709
710 /*!
711 * The function extracts an attribute value from the view. The user has to explicitly specify the
712 * type or set of possible types of the attribute value to be visited.
713 *
714 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
715 * a reference, if the temporary object is destroyed, the reference may become dangling.
716 *
717 * \param keyword The keyword of the attribute value to extract.
718 * \param rec A log record. The attribute value will be sought among those associated with the record.
719 * \param def_val The default value
720 * \return The extracted value, if found. The default value otherwise.
721 */
722 template< typename DescriptorT, template< typename > class ActorT, typename DefaultT >
723 inline typename result_of::extract_or_default< typename DescriptorT::value_type, DefaultT, DescriptorT >::type
extract_or_default(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,record const & rec,DefaultT const & def_val)724 extract_or_default(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record const& rec, DefaultT const& def_val)
725 {
726 typedef typename result_of::extract_or_default< typename DescriptorT::value_type, DefaultT, DescriptorT >::extracted_type extracted_type;
727 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, DescriptorT > extractor(def_val);
728 return aux::unwrap_value_ref(extractor(keyword.get_name(), rec));
729 }
730
731 /*!
732 * The function extracts an attribute value from the view. The user has to explicitly specify the
733 * type or set of possible types of the attribute value to be visited.
734 *
735 * \note Caution must be exercised if the default value is a temporary object. Because the function returns
736 * a reference, if the temporary object is destroyed, the reference may become dangling.
737 *
738 * \param keyword The keyword of the attribute value to extract.
739 * \param rec A log record view. The attribute value will be sought among those associated with the record.
740 * \param def_val The default value
741 * \return The extracted value, if found. The default value otherwise.
742 */
743 template< typename DescriptorT, template< typename > class ActorT, typename DefaultT >
744 inline typename result_of::extract_or_default< typename DescriptorT::value_type, DefaultT, DescriptorT >::type
extract_or_default(expressions::attribute_keyword<DescriptorT,ActorT> const & keyword,record_view const & rec,DefaultT const & def_val)745 extract_or_default(expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record_view const& rec, DefaultT const& def_val)
746 {
747 typedef typename result_of::extract_or_default< typename DescriptorT::value_type, DefaultT, DescriptorT >::extracted_type extracted_type;
748 value_extractor< extracted_type, fallback_to_default< DefaultT const& >, DescriptorT > extractor(def_val);
749 return aux::unwrap_value_ref(extractor(keyword.get_name(), rec));
750 }
751
752 #if !defined(BOOST_LOG_DOXYGEN_PASS)
753
754 template< typename T, typename TagT >
extract() const755 inline typename result_of::extract< T, TagT >::type attribute_value::extract() const
756 {
757 return boost::log::extract< T, TagT >(*this);
758 }
759
760 template< typename T, typename TagT >
extract_or_throw() const761 inline typename result_of::extract_or_throw< T, TagT >::type attribute_value::extract_or_throw() const
762 {
763 return boost::log::extract_or_throw< T, TagT >(*this);
764 }
765
766 template< typename T, typename TagT >
extract_or_default(T const & def_value) const767 inline typename result_of::extract_or_default< T, T, TagT >::type attribute_value::extract_or_default(T const& def_value) const
768 {
769 return boost::log::extract_or_default< T, TagT >(*this, def_value);
770 }
771
772 template< typename T, typename TagT, typename DefaultT >
extract_or_default(DefaultT const & def_value) const773 inline typename result_of::extract_or_default< T, DefaultT, TagT >::type attribute_value::extract_or_default(DefaultT const& def_value) const
774 {
775 return boost::log::extract_or_default< T, TagT >(*this, def_value);
776 }
777
778 #if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
779
780 template< typename T >
extract() const781 inline typename result_of::extract< T >::type attribute_value::extract() const
782 {
783 return boost::log::extract< T >(*this);
784 }
785
786 template< typename T >
extract_or_throw() const787 inline typename result_of::extract_or_throw< T >::type attribute_value::extract_or_throw() const
788 {
789 return boost::log::extract_or_throw< T >(*this);
790 }
791
792 template< typename T >
extract_or_default(T const & def_value) const793 inline typename result_of::extract_or_default< T, T >::type attribute_value::extract_or_default(T const& def_value) const
794 {
795 return boost::log::extract_or_default< T >(*this, def_value);
796 }
797
798 template< typename T, typename DefaultT >
extract_or_default(DefaultT const & def_value) const799 inline typename result_of::extract_or_default< T, DefaultT >::type attribute_value::extract_or_default(DefaultT const& def_value) const
800 {
801 return boost::log::extract_or_default< T >(*this, def_value);
802 }
803
804 #endif // defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
805
806 #endif // !defined(BOOST_LOG_DOXYGEN_PASS)
807
808 #undef BOOST_LOG_AUX_VOID_DEFAULT
809
810 BOOST_LOG_CLOSE_NAMESPACE // namespace log
811
812 } // namespace boost
813
814 #include <boost/log/detail/footer.hpp>
815
816 #endif // BOOST_LOG_ATTRIBUTES_VALUE_EXTRACTION_HPP_INCLUDED_
817