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 |
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 |
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 ; |
78 | |
79 | typedef typename mpl::if_< |
80 | mpl::is_sequence< extracted_type >, |
81 | value_ref< extracted_type, TagT >, |
82 | extracted_type const& |
83 | >::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 |
95 | { |
96 | typedef typename mpl::if_< |
97 | mpl::is_sequence< T >, |
98 | value_ref< T, TagT >, |
99 | T const& |
100 | >::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 |
110 | { |
111 | typedef value_ref< T, TagT > ; |
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 | |
124 | value_ref_initializer(RefT& ref) : m_ref(ref) |
125 | { |
126 | } |
127 | |
128 | template< typename ArgT > |
129 | 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 |
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 |
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 : |
164 | private FallbackPolicyT |
165 | { |
166 | public: |
167 | //! Fallback policy |
168 | typedef FallbackPolicyT ; |
169 | //! Attribute value types |
170 | typedef T ; |
171 | //! Function object result type |
172 | typedef value_ref< value_type, TagT > ; |
173 | |
174 | public: |
175 | /*! |
176 | * Default constructor |
177 | */ |
178 | BOOST_DEFAULTED_FUNCTION((), {}) |
179 | |
180 | /*! |
181 | * Copy constructor |
182 | */ |
183 | (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 > |
193 | explicit (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 | */ |
202 | result_type (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(dispatcher&: 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 | */ |
228 | result_type (attribute_name const& name, attribute_value_set const& attrs) const |
229 | { |
230 | try |
231 | { |
232 | attribute_value_set::const_iterator it = attrs.find(key: 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 | */ |
255 | result_type (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 | */ |
269 | result_type (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 | */ |
277 | fallback_policy const& () 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 > |
300 | inline typename result_of::extract< T, TagT >::type (attribute_name const& name, attribute_value_set const& attrs) |
301 | { |
302 | value_extractor< T, fallback_to_none, TagT > ; |
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 > |
315 | inline typename result_of::extract< T, TagT >::type (attribute_name const& name, record const& rec) |
316 | { |
317 | value_extractor< T, fallback_to_none, TagT > ; |
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 > |
330 | inline typename result_of::extract< T, TagT >::type (attribute_name const& name, record_view const& rec) |
331 | { |
332 | value_extractor< T, fallback_to_none, TagT > ; |
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 > |
344 | inline typename result_of::extract< T, TagT >::type (attribute_value const& value) |
345 | { |
346 | value_extractor< T, fallback_to_none, TagT > ; |
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 > |
360 | inline typename result_of::extract_or_throw< T, TagT >::type (attribute_name const& name, attribute_value_set const& attrs) |
361 | { |
362 | value_extractor< T, fallback_to_throw, TagT > ; |
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 > |
376 | inline typename result_of::extract_or_throw< T, TagT >::type (attribute_name const& name, record const& rec) |
377 | { |
378 | value_extractor< T, fallback_to_throw, TagT > ; |
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 > |
392 | inline typename result_of::extract_or_throw< T, TagT >::type (attribute_name const& name, record_view const& rec) |
393 | { |
394 | value_extractor< T, fallback_to_throw, TagT > ; |
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 > |
407 | inline typename result_of::extract_or_throw< T, TagT >::type (attribute_value const& value) |
408 | { |
409 | value_extractor< T, fallback_to_throw, TagT > ; |
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 |
427 | (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 ; |
430 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > (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 |
448 | (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 ; |
451 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > (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 |
469 | (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 ; |
472 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > (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 > |
488 | inline typename result_of::extract_or_default< T, DefaultT, TagT >::type (attribute_value const& value, DefaultT const& def_val) |
489 | { |
490 | typedef typename result_of::extract_or_default< T, DefaultT, TagT >::extracted_type ; |
491 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, TagT > (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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 > |
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 |
600 | (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, attribute_value_set const& attrs) |
601 | { |
602 | value_extractor< typename DescriptorT::value_type, fallback_to_none, DescriptorT > ; |
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 |
616 | (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record const& rec) |
617 | { |
618 | value_extractor< typename DescriptorT::value_type, fallback_to_none, DescriptorT > ; |
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 |
632 | (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record_view const& rec) |
633 | { |
634 | value_extractor< typename DescriptorT::value_type, fallback_to_none, DescriptorT > ; |
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 |
649 | (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, attribute_value_set const& attrs) |
650 | { |
651 | value_extractor< typename DescriptorT::value_type, fallback_to_throw, DescriptorT > ; |
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 |
666 | (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record const& rec) |
667 | { |
668 | value_extractor< typename DescriptorT::value_type, fallback_to_throw, DescriptorT > ; |
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 |
683 | (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword, record_view const& rec) |
684 | { |
685 | value_extractor< typename DescriptorT::value_type, fallback_to_throw, DescriptorT > ; |
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 |
703 | (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 ; |
706 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, DescriptorT > (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 |
724 | (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 ; |
727 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, DescriptorT > (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 |
745 | (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 ; |
748 | value_extractor< extracted_type, fallback_to_default< DefaultT const& >, DescriptorT > (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 > |
755 | inline typename result_of::extract< T, TagT >::type attribute_value::() const |
756 | { |
757 | return boost::log::extract< T, TagT >(*this); |
758 | } |
759 | |
760 | template< typename T, typename TagT > |
761 | inline typename result_of::extract_or_throw< T, TagT >::type attribute_value::() const |
762 | { |
763 | return boost::log::extract_or_throw< T, TagT >(*this); |
764 | } |
765 | |
766 | template< typename T, typename TagT > |
767 | inline typename result_of::extract_or_default< T, T, TagT >::type attribute_value::(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 > |
773 | inline typename result_of::extract_or_default< T, DefaultT, TagT >::type attribute_value::(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 > |
781 | 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 > |
787 | 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 > |
793 | 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 > |
799 | 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 | |