475 lines
15 KiB
C++
475 lines
15 KiB
C++
|
/*
|
||
|
|
* 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
|
||
|
|
* \author Andrey Semashev
|
||
|
|
* \date 24.06.2007
|
||
|
|
*
|
||
|
|
* The header contains implementation of named scope container and an attribute that allows to
|
||
|
|
* put the named scope to log. A number of convenience macros are also provided.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef BOOST_LOG_ATTRIBUTES_NAMED_SCOPE_HPP_INCLUDED_
|
||
|
|
#define BOOST_LOG_ATTRIBUTES_NAMED_SCOPE_HPP_INCLUDED_
|
||
|
|
|
||
|
|
#include <ostream>
|
||
|
|
#include <memory>
|
||
|
|
#include <iterator>
|
||
|
|
#include <cstddef>
|
||
|
|
#include <boost/log/detail/config.hpp>
|
||
|
|
#include <boost/current_function.hpp>
|
||
|
|
#include <boost/mpl/if.hpp>
|
||
|
|
#include <boost/log/utility/string_literal.hpp>
|
||
|
|
#include <boost/log/utility/unique_identifier_name.hpp>
|
||
|
|
#include <boost/log/utility/unused_variable.hpp>
|
||
|
|
#include <boost/log/attributes/attribute.hpp>
|
||
|
|
#include <boost/log/attributes/attribute_cast.hpp>
|
||
|
|
#include <boost/log/detail/header.hpp>
|
||
|
|
|
||
|
|
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||
|
|
#pragma once
|
||
|
|
#endif
|
||
|
|
|
||
|
|
namespace boost {
|
||
|
|
|
||
|
|
BOOST_LOG_OPEN_NAMESPACE
|
||
|
|
|
||
|
|
namespace attributes {
|
||
|
|
|
||
|
|
namespace aux {
|
||
|
|
|
||
|
|
//! Double-linked list node
|
||
|
|
struct named_scope_list_node
|
||
|
|
{
|
||
|
|
mutable named_scope_list_node* _m_pPrev;
|
||
|
|
mutable named_scope_list_node* _m_pNext;
|
||
|
|
|
||
|
|
named_scope_list_node() BOOST_NOEXCEPT { _m_pPrev = _m_pNext = this; }
|
||
|
|
};
|
||
|
|
|
||
|
|
} // namespace aux
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \brief The structure contains all information about a named scope
|
||
|
|
*
|
||
|
|
* The named scope entries are stored as elements of \c basic_named_scope_list container, which
|
||
|
|
* in turn can be acquired either from the \c basic_named_scope attribute value or from a thread-local
|
||
|
|
* instance.
|
||
|
|
*/
|
||
|
|
struct named_scope_entry
|
||
|
|
//! \cond
|
||
|
|
: public aux::named_scope_list_node
|
||
|
|
//! \endcond
|
||
|
|
{
|
||
|
|
/*!
|
||
|
|
* \brief Scope entry type
|
||
|
|
*
|
||
|
|
* Describes scope name specifics
|
||
|
|
*/
|
||
|
|
enum scope_name_type
|
||
|
|
{
|
||
|
|
general, //!< The scope name contains some unstructured string that should not be interpreted by the library
|
||
|
|
function //!< The scope name contains a function signature
|
||
|
|
};
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* The scope name (e.g. a function signature)
|
||
|
|
*/
|
||
|
|
string_literal scope_name;
|
||
|
|
/*!
|
||
|
|
* The source file name
|
||
|
|
*/
|
||
|
|
string_literal file_name;
|
||
|
|
/*!
|
||
|
|
* The line number in the source file
|
||
|
|
*/
|
||
|
|
unsigned int line;
|
||
|
|
/*!
|
||
|
|
* The scope name type
|
||
|
|
*/
|
||
|
|
scope_name_type type;
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Initializing constructor
|
||
|
|
*
|
||
|
|
* \post <tt>scope_name == sn && file_name == fn && line == ln</tt>
|
||
|
|
*
|
||
|
|
* \b Throws: Nothing.
|
||
|
|
*/
|
||
|
|
named_scope_entry(string_literal const& sn, string_literal const& fn, unsigned int ln, scope_name_type t = general) BOOST_NOEXCEPT :
|
||
|
|
scope_name(sn),
|
||
|
|
file_name(fn),
|
||
|
|
line(ln),
|
||
|
|
type(t)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \brief The class implements the list of scopes
|
||
|
|
*
|
||
|
|
* The scope list provides a read-only access to a doubly-linked list of scopes.
|
||
|
|
*/
|
||
|
|
class named_scope_list
|
||
|
|
//! \cond
|
||
|
|
: protected std::allocator< named_scope_entry >
|
||
|
|
//! \endcond
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
//! Allocator type
|
||
|
|
typedef std::allocator< named_scope_entry > allocator_type;
|
||
|
|
|
||
|
|
// Standard types
|
||
|
|
typedef allocator_type::value_type value_type;
|
||
|
|
typedef allocator_type::reference reference;
|
||
|
|
typedef allocator_type::const_reference const_reference;
|
||
|
|
typedef allocator_type::pointer pointer;
|
||
|
|
typedef allocator_type::const_pointer const_pointer;
|
||
|
|
typedef allocator_type::size_type size_type;
|
||
|
|
typedef allocator_type::difference_type difference_type;
|
||
|
|
|
||
|
|
#ifndef BOOST_LOG_DOXYGEN_PASS
|
||
|
|
|
||
|
|
protected:
|
||
|
|
//! Iterator class
|
||
|
|
#ifndef BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS
|
||
|
|
template< bool fConstV > class iter;
|
||
|
|
template< bool fConstV > friend class iter;
|
||
|
|
#endif
|
||
|
|
template< bool fConstV >
|
||
|
|
class iter
|
||
|
|
{
|
||
|
|
friend class iter< !fConstV >;
|
||
|
|
|
||
|
|
public:
|
||
|
|
// Standard typedefs
|
||
|
|
typedef named_scope_list::difference_type difference_type;
|
||
|
|
typedef named_scope_list::value_type value_type;
|
||
|
|
typedef typename mpl::if_c<
|
||
|
|
fConstV,
|
||
|
|
named_scope_list::const_reference,
|
||
|
|
named_scope_list::reference
|
||
|
|
>::type reference;
|
||
|
|
typedef typename mpl::if_c<
|
||
|
|
fConstV,
|
||
|
|
named_scope_list::const_pointer,
|
||
|
|
named_scope_list::pointer
|
||
|
|
>::type pointer;
|
||
|
|
typedef std::bidirectional_iterator_tag iterator_category;
|
||
|
|
|
||
|
|
public:
|
||
|
|
// Constructors
|
||
|
|
iter() : m_pNode(NULL) {}
|
||
|
|
explicit iter(aux::named_scope_list_node* pNode) : m_pNode(pNode) {}
|
||
|
|
iter(iter< false > const& that) : m_pNode(that.m_pNode) {}
|
||
|
|
|
||
|
|
//! Assignment
|
||
|
|
template< bool f >
|
||
|
|
iter& operator= (iter< f > const& that)
|
||
|
|
{
|
||
|
|
m_pNode = that.m_pNode;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Comparison
|
||
|
|
template< bool f >
|
||
|
|
bool operator== (iter< f > const& that) const { return (m_pNode == that.m_pNode); }
|
||
|
|
template< bool f >
|
||
|
|
bool operator!= (iter< f > const& that) const { return (m_pNode != that.m_pNode); }
|
||
|
|
|
||
|
|
// Modification
|
||
|
|
iter& operator++ ()
|
||
|
|
{
|
||
|
|
m_pNode = m_pNode->_m_pNext;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
iter& operator-- ()
|
||
|
|
{
|
||
|
|
m_pNode = m_pNode->_m_pPrev;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
iter operator++ (int)
|
||
|
|
{
|
||
|
|
iter tmp(*this);
|
||
|
|
m_pNode = m_pNode->_m_pNext;
|
||
|
|
return tmp;
|
||
|
|
}
|
||
|
|
iter operator-- (int)
|
||
|
|
{
|
||
|
|
iter tmp(*this);
|
||
|
|
m_pNode = m_pNode->_m_pPrev;
|
||
|
|
return tmp;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Dereferencing
|
||
|
|
pointer operator-> () const { return static_cast< pointer >(m_pNode); }
|
||
|
|
reference operator* () const { return *static_cast< pointer >(m_pNode); }
|
||
|
|
|
||
|
|
private:
|
||
|
|
aux::named_scope_list_node* m_pNode;
|
||
|
|
};
|
||
|
|
|
||
|
|
public:
|
||
|
|
typedef iter< true > const_iterator;
|
||
|
|
typedef iter< false > iterator;
|
||
|
|
typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
|
||
|
|
typedef std::reverse_iterator< iterator > reverse_iterator;
|
||
|
|
|
||
|
|
protected:
|
||
|
|
//! The root node of the container
|
||
|
|
aux::named_scope_list_node m_RootNode;
|
||
|
|
//! The size of the container
|
||
|
|
size_type m_Size;
|
||
|
|
//! The flag shows if the contained elements are dynamically allocated
|
||
|
|
bool m_fNeedToDeallocate;
|
||
|
|
|
||
|
|
#else // BOOST_LOG_DOXYGEN_PASS
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* A constant iterator to the sequence of scopes. Complies to bidirectional iterator requirements.
|
||
|
|
*/
|
||
|
|
typedef implementation_defined const_iterator;
|
||
|
|
/*!
|
||
|
|
* An iterator to the sequence of scopes. Complies to bidirectional iterator requirements.
|
||
|
|
*/
|
||
|
|
typedef implementation_defined iterator;
|
||
|
|
/*!
|
||
|
|
* A constant reverse iterator to the sequence of scopes. Complies to bidirectional iterator requirements.
|
||
|
|
*/
|
||
|
|
typedef implementation_defined const_reverse_iterator;
|
||
|
|
/*!
|
||
|
|
* A reverse iterator to the sequence of scopes. Complies to bidirectional iterator requirements.
|
||
|
|
*/
|
||
|
|
typedef implementation_defined reverse_iterator;
|
||
|
|
|
||
|
|
#endif // BOOST_LOG_DOXYGEN_PASS
|
||
|
|
|
||
|
|
public:
|
||
|
|
/*!
|
||
|
|
* Default constructor
|
||
|
|
*
|
||
|
|
* \post <tt>empty() == true</tt>
|
||
|
|
*/
|
||
|
|
named_scope_list() : m_Size(0), m_fNeedToDeallocate(false) {}
|
||
|
|
/*!
|
||
|
|
* Copy constructor
|
||
|
|
*
|
||
|
|
* \post <tt>std::equal(begin(), end(), that.begin()) == true</tt>
|
||
|
|
*/
|
||
|
|
BOOST_LOG_API named_scope_list(named_scope_list const& that);
|
||
|
|
/*!
|
||
|
|
* Destructor. Destroys the stored entries.
|
||
|
|
*/
|
||
|
|
BOOST_LOG_API ~named_scope_list();
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Assignment operator
|
||
|
|
*
|
||
|
|
* \post <tt>std::equal(begin(), end(), that.begin()) == true</tt>
|
||
|
|
*/
|
||
|
|
named_scope_list& operator= (named_scope_list const& that)
|
||
|
|
{
|
||
|
|
if (this != &that)
|
||
|
|
{
|
||
|
|
named_scope_list tmp(that);
|
||
|
|
swap(tmp);
|
||
|
|
}
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \return Constant iterator to the first element of the container.
|
||
|
|
*/
|
||
|
|
const_iterator begin() const { return const_iterator(m_RootNode._m_pNext); }
|
||
|
|
/*!
|
||
|
|
* \return Constant iterator to the after-the-last element of the container.
|
||
|
|
*/
|
||
|
|
const_iterator end() const { return const_iterator(const_cast< aux::named_scope_list_node* >(&m_RootNode)); }
|
||
|
|
/*!
|
||
|
|
* \return Constant iterator to the last element of the container.
|
||
|
|
*/
|
||
|
|
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
|
||
|
|
/*!
|
||
|
|
* \return Constant iterator to the before-the-first element of the container.
|
||
|
|
*/
|
||
|
|
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \return The number of elements in the container
|
||
|
|
*/
|
||
|
|
size_type size() const { return m_Size; }
|
||
|
|
/*!
|
||
|
|
* \return true if the container is empty and false otherwise
|
||
|
|
*/
|
||
|
|
bool empty() const { return (m_Size == 0); }
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Swaps two instances of the container
|
||
|
|
*/
|
||
|
|
BOOST_LOG_API void swap(named_scope_list& that);
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \return Last pushed scope entry
|
||
|
|
*/
|
||
|
|
const_reference back() const { return *rbegin(); }
|
||
|
|
/*!
|
||
|
|
* \return First pushed scope entry
|
||
|
|
*/
|
||
|
|
const_reference front() const { return *begin(); }
|
||
|
|
};
|
||
|
|
|
||
|
|
//! Stream output operator
|
||
|
|
template< typename CharT, typename TraitsT >
|
||
|
|
inline std::basic_ostream< CharT, TraitsT >& operator<< (std::basic_ostream< CharT, TraitsT >& strm, named_scope_list const& sl)
|
||
|
|
{
|
||
|
|
if (strm.good())
|
||
|
|
{
|
||
|
|
named_scope_list::const_iterator it = sl.begin(), end = sl.end();
|
||
|
|
if (it != end)
|
||
|
|
{
|
||
|
|
strm << it->scope_name.c_str();
|
||
|
|
for (++it; it != end; ++it)
|
||
|
|
strm << "->" << it->scope_name.c_str();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return strm;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \brief A class of an attribute that holds stack of named scopes of the current thread
|
||
|
|
*
|
||
|
|
* The basic_named_scope attribute is essentially a hook to the thread-specific instance of
|
||
|
|
* scope list. This means that the attribute will generate different values if get_value is
|
||
|
|
* called in different threads. The attribute generates value with stored type
|
||
|
|
* <tt>basic_named_scope_list< CharT ></tt>.
|
||
|
|
*
|
||
|
|
* The attribute class can also be used to gain access to the scope stack instance, e.g. to
|
||
|
|
* get its copy or to push or pop a scope entry. However, it is highly not recommended to
|
||
|
|
* maintain scope list manually. Use \c BOOST_LOG_NAMED_SCOPE or \c BOOST_LOG_FUNCTION macros instead.
|
||
|
|
*/
|
||
|
|
class BOOST_LOG_API named_scope :
|
||
|
|
public attribute
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
//! Scope names stack (the attribute value type)
|
||
|
|
typedef named_scope_list value_type;
|
||
|
|
//! Scope entry
|
||
|
|
typedef value_type::value_type scope_entry;
|
||
|
|
|
||
|
|
//! Sentry object class to automatically push and pop scopes
|
||
|
|
struct sentry
|
||
|
|
{
|
||
|
|
/*!
|
||
|
|
* Constructor. Pushes the specified scope to the end of the thread-local list of scopes.
|
||
|
|
*
|
||
|
|
* \param sn Scope name.
|
||
|
|
* \param fn File name, in which the scope is located.
|
||
|
|
* \param ln Line number in the file.
|
||
|
|
*/
|
||
|
|
sentry(string_literal const& sn, string_literal const& fn, unsigned int ln, scope_entry::scope_name_type t = scope_entry::general) BOOST_NOEXCEPT :
|
||
|
|
m_Entry(sn, fn, ln, t)
|
||
|
|
{
|
||
|
|
named_scope::push_scope(m_Entry);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Destructor. Removes the last pushed scope from the thread-local list of scopes.
|
||
|
|
*/
|
||
|
|
~sentry() BOOST_NOEXCEPT
|
||
|
|
{
|
||
|
|
named_scope::pop_scope();
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_DELETED_FUNCTION(sentry(sentry const&))
|
||
|
|
BOOST_DELETED_FUNCTION(sentry& operator= (sentry const&))
|
||
|
|
|
||
|
|
private:
|
||
|
|
scope_entry m_Entry;
|
||
|
|
};
|
||
|
|
|
||
|
|
private:
|
||
|
|
//! Attribute implementation class
|
||
|
|
struct BOOST_SYMBOL_VISIBLE impl;
|
||
|
|
|
||
|
|
public:
|
||
|
|
/*!
|
||
|
|
* Constructor. Creates an attribute.
|
||
|
|
*/
|
||
|
|
named_scope();
|
||
|
|
/*!
|
||
|
|
* Constructor for casting support
|
||
|
|
*/
|
||
|
|
explicit named_scope(cast_source const& source);
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* The method pushes the scope to the back of the current thread's scope list
|
||
|
|
*
|
||
|
|
* \b Throws: Nothing.
|
||
|
|
*/
|
||
|
|
static void push_scope(scope_entry const& entry) BOOST_NOEXCEPT;
|
||
|
|
/*!
|
||
|
|
* The method pops the last pushed scope from the current thread's scope list
|
||
|
|
*
|
||
|
|
* \b Throws: Nothing.
|
||
|
|
*/
|
||
|
|
static void pop_scope() BOOST_NOEXCEPT;
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* \return The current thread's list of scopes
|
||
|
|
*
|
||
|
|
* \note The returned reference is only valid until the current thread ends. The scopes in the
|
||
|
|
* returned container may change if the execution scope is changed (i.e. either \c push_scope
|
||
|
|
* or \c pop_scope is called). User has to copy the stack if he wants to keep it intact regardless
|
||
|
|
* of the execution scope.
|
||
|
|
*/
|
||
|
|
static value_type const& get_scopes();
|
||
|
|
};
|
||
|
|
|
||
|
|
} // namespace attributes
|
||
|
|
|
||
|
|
BOOST_LOG_CLOSE_NAMESPACE // namespace log
|
||
|
|
|
||
|
|
} // namespace boost
|
||
|
|
|
||
|
|
#ifndef BOOST_LOG_DOXYGEN_PASS
|
||
|
|
|
||
|
|
#define BOOST_LOG_NAMED_SCOPE_INTERNAL(var, name, file, line, type)\
|
||
|
|
BOOST_LOG_UNUSED_VARIABLE(::boost::log::attributes::named_scope::sentry, var, (name, file, line, type));
|
||
|
|
|
||
|
|
#endif // BOOST_LOG_DOXYGEN_PASS
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Macro for scope markup. The specified scope name is pushed to the end of the current thread scope list.
|
||
|
|
*/
|
||
|
|
#define BOOST_LOG_NAMED_SCOPE(name)\
|
||
|
|
BOOST_LOG_NAMED_SCOPE_INTERNAL(BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_named_scope_sentry_), name, __FILE__, __LINE__, ::boost::log::attributes::named_scope_entry::general)
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Macro for function scope markup. The scope name is constructed with help of compiler and contains the current function signature.
|
||
|
|
* The scope name is pushed to the end of the current thread scope list.
|
||
|
|
*
|
||
|
|
* Not all compilers have support for this macro. The exact form of the scope name may vary from one compiler to another.
|
||
|
|
*/
|
||
|
|
#define BOOST_LOG_FUNCTION()\
|
||
|
|
BOOST_LOG_NAMED_SCOPE_INTERNAL(BOOST_LOG_UNIQUE_IDENTIFIER_NAME(_boost_log_named_scope_sentry_), BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, ::boost::log::attributes::named_scope_entry::function)
|
||
|
|
|
||
|
|
/*!
|
||
|
|
* Macro for function scope markup. The scope name is constructed with help of compiler and contains the current function name. It may be shorter than what \c BOOST_LOG_FUNCTION macro produces.
|
||
|
|
* The scope name is pushed to the end of the current thread scope list.
|
||
|
|
*
|
||
|
|
* Not all compilers have support for this macro. The exact form of the scope name may vary from one compiler to another.
|
||
|
|
*/
|
||
|
|
#if defined(_MSC_VER) || defined(__GNUC__)
|
||
|
|
#define BOOST_LOG_FUNC() BOOST_LOG_NAMED_SCOPE(__FUNCTION__)
|
||
|
|
#else
|
||
|
|
#define BOOST_LOG_FUNC() BOOST_LOG_FUNCTION()
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <boost/log/detail/footer.hpp>
|
||
|
|
|
||
|
|
#endif // BOOST_LOG_ATTRIBUTES_NAMED_SCOPE_HPP_INCLUDED_
|