ceph/src/boost/libs/log/include/boost/log/attributes/value_extraction.hpp

   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
 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 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      */
 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 >
 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      */
 202     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      */
 228     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      */
 255     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      */
 269     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      */
 277     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 >
 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 >
 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 >
 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 >
 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 >
 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 >
 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 >
 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 >
 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
 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
 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
 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 >
 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 >
 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 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
 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
 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
 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
 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
 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
 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
 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
 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 >
 755 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 >
 761 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 >
 767 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 >
 773 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 >
 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_