| /* |
| * Copyright Andrey Semashev 2007 - 2015. |
| * Distributed under the Boost Software License, Version 1.0. |
| * (See accompanying file LICENSE_1_0.txt or copy at |
| * http://www.boost.org/LICENSE_1_0.txt) |
| */ |
| /*! |
| * \file record.hpp |
| * \author Andrey Semashev |
| * \date 09.03.2009 |
| * |
| * This header contains a logging record class definition. |
| */ |
| |
| #ifndef BOOST_LOG_CORE_RECORD_HPP_INCLUDED_ |
| #define BOOST_LOG_CORE_RECORD_HPP_INCLUDED_ |
| |
| #include <boost/move/core.hpp> |
| #include <boost/log/detail/config.hpp> |
| #include <boost/utility/explicit_operator_bool.hpp> |
| #include <boost/log/attributes/attribute_value_set.hpp> |
| #include <boost/log/expressions/keyword_fwd.hpp> |
| #include <boost/log/core/record_view.hpp> |
| #include <boost/log/detail/header.hpp> |
| |
| #ifdef BOOST_HAS_PRAGMA_ONCE |
| #pragma once |
| #endif |
| |
| namespace boost { |
| |
| BOOST_LOG_OPEN_NAMESPACE |
| |
| class core; |
| |
| /*! |
| * \brief Logging record class |
| * |
| * The logging record encapsulates all information related to a single logging statement, |
| * in particular, attribute values view and the log message string. The record can be updated before pushing |
| * for further processing to the logging core. |
| */ |
| class record |
| { |
| BOOST_MOVABLE_BUT_NOT_COPYABLE(record) |
| |
| friend class core; |
| |
| #ifndef BOOST_LOG_DOXYGEN_PASS |
| private: |
| //! Private data |
| typedef record_view::public_data public_data; |
| |
| private: |
| //! A pointer to the log record implementation |
| public_data* m_impl; |
| |
| #endif // BOOST_LOG_DOXYGEN_PASS |
| |
| public: |
| /*! |
| * Default constructor. Creates an empty record that is equivalent to the invalid record handle. |
| * |
| * \post <tt>!*this == true</tt> |
| */ |
| record() : m_impl(NULL) {} |
| |
| /*! |
| * Move constructor. Source record contents unspecified after the operation. |
| */ |
| record(BOOST_RV_REF(record) that) BOOST_NOEXCEPT : m_impl(that.m_impl) |
| { |
| that.m_impl = NULL; |
| } |
| |
| /*! |
| * Destructor. Destroys the record, releases any sinks and attribute values that were involved in processing this record. |
| */ |
| ~record() BOOST_NOEXCEPT |
| { |
| reset(); |
| } |
| |
| /*! |
| * Move assignment. Source record contents unspecified after the operation. |
| */ |
| record& operator= (BOOST_RV_REF(record) that) BOOST_NOEXCEPT |
| { |
| swap(static_cast< record& >(that)); |
| return *this; |
| } |
| |
| /*! |
| * \return A reference to the set of attribute values attached to this record |
| * |
| * \pre <tt>!!*this</tt> |
| */ |
| attribute_value_set& attribute_values() BOOST_NOEXCEPT |
| { |
| return m_impl->m_attribute_values; |
| } |
| |
| /*! |
| * \return A reference to the set of attribute values attached to this record |
| * |
| * \pre <tt>!!*this</tt> |
| */ |
| attribute_value_set const& attribute_values() const BOOST_NOEXCEPT |
| { |
| return m_impl->m_attribute_values; |
| } |
| |
| /*! |
| * Conversion to an unspecified boolean type |
| * |
| * \return \c true, if the <tt>*this</tt> identifies a log record, \c false, if the <tt>*this</tt> is not valid |
| */ |
| BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT() |
| |
| /*! |
| * Inverted conversion to an unspecified boolean type |
| * |
| * \return \c false, if the <tt>*this</tt> identifies a log record, \c true, if the <tt>*this</tt> is not valid |
| */ |
| bool operator! () const BOOST_NOEXCEPT |
| { |
| return !m_impl; |
| } |
| |
| /*! |
| * Swaps two handles |
| * |
| * \param that Another record to swap with |
| * <b>Throws:</b> Nothing |
| */ |
| void swap(record& that) BOOST_NOEXCEPT |
| { |
| public_data* p = m_impl; |
| m_impl = that.m_impl; |
| that.m_impl = p; |
| } |
| |
| /*! |
| * Resets the log record handle. If there are no other handles left, the log record is closed |
| * and all resources referenced by the record are released. |
| * |
| * \post <tt>!*this == true</tt> |
| */ |
| void reset() BOOST_NOEXCEPT |
| { |
| if (m_impl) |
| { |
| public_data::destroy(m_impl); |
| m_impl = NULL; |
| } |
| } |
| |
| /*! |
| * Attribute value lookup. |
| * |
| * \param name Attribute name. |
| * \return An \c attribute_value, non-empty if it is found, empty otherwise. |
| */ |
| attribute_value_set::mapped_type operator[] (attribute_value_set::key_type name) const |
| { |
| return m_impl->m_attribute_values[name]; |
| } |
| |
| /*! |
| * Attribute value lookup. |
| * |
| * \param keyword Attribute keyword. |
| * \return A \c value_ref with extracted attribute value if it is found, empty \c value_ref otherwise. |
| */ |
| template< typename DescriptorT, template< typename > class ActorT > |
| typename result_of::extract< typename expressions::attribute_keyword< DescriptorT, ActorT >::value_type, DescriptorT >::type |
| operator[] (expressions::attribute_keyword< DescriptorT, ActorT > const& keyword) const |
| { |
| return m_impl->m_attribute_values[keyword]; |
| } |
| |
| /*! |
| * The function ensures that the log record does not depend on any thread-specific data. Then the record contents |
| * are used to construct a \c record_view which is returned from the function. The record is no longer valid after the call. |
| * |
| * \pre <tt>!!*this</tt> |
| * \post <tt>!*this</tt> |
| * \returns The record view that contains all attribute values from the original record. |
| */ |
| BOOST_LOG_API record_view lock(); |
| }; |
| |
| /*! |
| * A free-standing swap function overload for \c record |
| */ |
| inline void swap(record& left, record& right) BOOST_NOEXCEPT |
| { |
| left.swap(right); |
| } |
| |
| BOOST_LOG_CLOSE_NAMESPACE // namespace log |
| |
| } // namespace boost |
| |
| #include <boost/log/detail/footer.hpp> |
| |
| #endif // BOOST_LOG_CORE_RECORD_HPP_INCLUDED_ |